LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/0xADE1A1DE[P]MeasureSuite/lib/src/io/elf_file.c
// Function: read_section
static int read_section(int32_t file, Elf64_Shdr sect_hdr, void **dest) {

  *dest = malloc(sect_hdr.sh_size);
  if (!dest) {
    fprintf(stderr, "%s:Failed to allocate %ldbytes\n", __func__,
            sect_hdr.sh_size);
    return 1;
  }

  if (lseek(file, (off_t)sect_hdr.sh_offset, SEEK_SET) !=
      (off_t)sect_hdr.sh_offset) {
    return 1;
  };
  ssize_t bytes_read = read(file, *dest, sect_hdr.sh_size);
  if (bytes_read == -1 || bytes_read == 0 || bytes_read == EOF ||
      (size_t)bytes_read != sect_hdr.sh_size) {
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x20(%rax), %rdi
callq 0x21b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x5af1
movq -0x20(%rbp), %rax
movq 0x552c(%rip), %rcx      # 0xaff8
movq (%rcx), %rdi
movq 0x20(%rax), %rcx
leaq 0x25be(%rip), %rsi      # 0x8098
leaq 0x25e8(%rip), %rdx      # 0x80c9
movb $0x0, %al
callq 0x2180
movl $0x1, -0x4(%rbp)
jmp 0x5b64
movq -0x20(%rbp), %rax
movl -0x8(%rbp), %edi
movq 0x18(%rax), %rsi
xorl %edx, %edx
callq 0x20e0
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x5b16
movl $0x1, -0x4(%rbp)
jmp 0x5b64
movq -0x20(%rbp), %rax
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
movq 0x20(%rax), %rdx
callq 0x2140
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x5b54
cmpq $0x0, -0x18(%rbp)
je 0x5b54
cmpq $-0x1, -0x18(%rbp)
je 0x5b54
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x20(%rcx), %rax
je 0x5b5d
movl $0x1, -0x4(%rbp)
jmp 0x5b64
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/0xADE1A1DE[P]MeasureSuite/lib/src/io/elf_file.c
// Function: read_elf_header
int read_elf_header(int32_t file, Elf64_Ehdr *elf_header) {
  size_t size = sizeof(Elf64_Ehdr);
  char magic[] = {"\177ELF"};
  if (elf_header == NULL                                     // sanity
      || lseek(file, (off_t)0, SEEK_SET) != (off_t)0         // seek to start
      || (size_t)read(file, elf_header, size) != size        // read header
      || strncmp((char *)elf_header->e_ident, magic, 4) != 0 // check magic
      || elf_header->e_ident[EI_CLASS] != ELFCLASS64         // is elf64
  ) {
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x40, -0x18(%rbp)
movl 0x22d6(%rip), %eax      # 0x8093
movl %eax, -0x1d(%rbp)
movb 0x22d1(%rip), %al       # 0x8097
movb %al, -0x19(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5e1e
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x20e0
cmpq $0x0, %rax
jne 0x5e1e
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2140
cmpq -0x18(%rbp), %rax
jne 0x5e1e
movq -0x10(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
movl $0x4, %edx
callq 0x2070
cmpl $0x0, %eax
jne 0x5e1e
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x2, %eax
je 0x5e27
movl $0x1, -0x4(%rbp)
jmp 0x5e2e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0xADE1A1DE[P]MeasureSuite/lib/src/fisher_yates.c
// Function: shuffle_permutations
int shuffle_permutations(measuresuite_t ms) {

  // nothing to shuffle if we didn't load any functions yet / there is only one
  // function
  if (ms->num_functions <= 1) {
    return 0;
  }

  for (size_t i = ms->num_functions - 1; // start with last item
       i >= 1; // until second item (no need to shuffle first item with itself)
       i--     // every item
  ) {
    size_t num = 0;
    if (get_random_number(ms, i, &num)) {
      return 1;
    }
    // swap random with current
    size_t tmp = ms->permutation[i];
    ms->permutation[i] = ms->permutation[num];
    ms->permutation[num] = tmp;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x80(%rax)
ja 0x6306
movl $0x0, -0x4(%rbp)
jmp 0x63ab
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jb 0x63a4
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3360
cmpl $0x0, %eax
je 0x634b
movl $0x1, -0x4(%rbp)
jmp 0x63ab
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6319
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/0xADE1A1DE[P]MeasureSuite/lib/src/printer.c
// Function: pretty_print_results
void pretty_print_results(uint64_t const *data_a, uint64_t const *data_b,
                          size_t total) {

  for (size_t i = 0; i < total; i++) {

    uint64_t ground_truth = data_a[i];
    uint64_t val = data_b[i];
    printf("\n\x1b[%dm@ %lu/%lu\x1b[0m:\n"
           "a:0x",
           color_grn - (val != ground_truth), i, total);

    printbin_single_number_hex(ground_truth, ground_truth);
#ifdef ENABLE_DEBUG
    printbin_single_number_bin(ground_truth, ground_truth);
#endif
    printf("\n\x1b[0mb:0x");

    printbin_single_number_hex(val, ground_truth);
#ifdef ENABLE_DEBUG
    printbin_single_number_bin(val, ground_truth);
#endif

    printf("\n");
    data_b++;
    data_a++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x6496
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl $0x20, %esi
subl %eax, %esi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x1d6c(%rip), %rdi      # 0x819c
movb $0x0, %al
callq 0x20b0
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x64a0
leaq 0x1d6b(%rip), %rdi      # 0x81b6
movb $0x0, %al
callq 0x20b0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x64a0
leaq 0xd54(%rip), %rdi       # 0x71ba
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x63dc
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/0xADE1A1DE[P]MeasureSuite/lib/src/printer.c
// Function: printbin_single_number_hex
static void printbin_single_number_hex(uint64_t num, uint64_t compare) {

  const short bits_in_u64 = 64;
  const short bits_in_nibble = 4;
  const char nibble_mask = 0xF;

  int width = bits_in_u64 - bits_in_nibble;
  while (width >= 0) {
    unsigned long value = (num >> width) & nibble_mask;
    unsigned long truth = (compare >> width) & nibble_mask;
    int color = color_grn - (truth != value); // col 32 when its equal, grn

    printf("\x1b[%dm%lx", color, value);
    width -= bits_in_nibble;
  }
  printf("\x1b[0m");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw $0x40, -0x12(%rbp)
movw $0x4, -0x14(%rbp)
movb $0xf, -0x15(%rbp)
movl $0x3c, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x652b
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shrq %cl, %rax
andq $0xf, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
shrq %cl, %rax
andq $0xf, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %ecx
movl $0x20, %eax
subl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
movq -0x28(%rbp), %rdx
leaq 0x1ca7(%rip), %rdi      # 0x81c0
movb $0x0, %al
callq 0x20b0
movl -0x1c(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0x64c7
leaq 0x1c97(%rip), %rdi      # 0x81c9
movb $0x0, %al
callq 0x20b0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_01/passwd.c
// Function: main
int main(void) {
	struct passwd *pwd;

	setpwent();
	while((pwd = getpwent()) != NULL)
		printf("uid=%d gid=%d name=%s\n",
			pwd->pw_uid, pwd->pw_gid, pwd->pw_name);
	endpwent();

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1040
callq 0x1050
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x11b8
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0xe55(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
jmp 0x1184
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_03/dup2.c
// Function: main
int main(void)
{
	int ret;

	ret = dup2(STDOUT_FILENO, STDERR_FILENO);
	if (ret < 0) {
		perror("dup2");
		return -1;
	}

	/* WARNING: this is an example! NEVER, NEVER, NEVER call
	 *          a system call without checking its return value!
	 */
	write(STDOUT_FILENO, "stdout\n", 7);
	write(STDERR_FILENO, "stderr\n", 7);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x1, %edi
movl $0x2, %esi
callq 0x1040
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x119c
leaq 0xe76(%rip), %rdi       # 0x2004
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11cf
movl $0x1, %edi
leaq 0xe61(%rip), %rsi       # 0x2009
movl $0x7, %edx
callq 0x1030
movl $0x2, %edi
leaq 0xe53(%rip), %rsi       # 0x2011
movl $0x7, %edx
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/accre[P]Cprogramming/structures.c
// Function: printStruct
void printStruct( student oneStudent )
{
   int i;

   printf("=====================\n");
   printf("Student name: %s\n",oneStudent.name);
   printf("        age: %d\n",oneStudent.age);
   printf("        height: %6.3f\n",oneStudent.height);
   printf("        grades: ");
   for (i=0; i<10; i++) printf("%4.1f ",oneStudent.grades[i]);
   printf("\n");
   printf("=====================\n");

   // note that we're just changing the age of the local
   // copy here, so this will not affect the age of the 
   // original struct created in main()
   oneStudent.age = 45;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xec1(%rip), %rdi       # 0x2018
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xec3(%rip), %rdi       # 0x202f
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0xec0(%rip), %rdi       # 0x2041
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xeb6(%rip), %rdi       # 0x2052
movb $0x1, %al
callq 0x1030
leaq 0xebf(%rip), %rdi       # 0x2069
movb $0x0, %al
callq 0x1030
movl $0x0, -0x4(%rbp)
cmpl $0xa, -0x4(%rbp)
jge 0x11e9
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movss 0x10(%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xea3(%rip), %rdi       # 0x207a
movb $0x1, %al
callq 0x1030
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x11b8
leaq 0xe3d(%rip), %rdi       # 0x202d
movb $0x0, %al
callq 0x1030
leaq 0xe1a(%rip), %rdi       # 0x2018
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movl $0x2d, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/accre[P]Cprogramming/structures.c
// Function: main
int main()
{

   student Nikki;
   Nikki.name = "Nikki";
   Nikki.age = 19;
   Nikki.height = 64.75;
   int i;
   for (i=0; i<10 ; i++) {
      Nikki.grades[i] = 98.0; // overachiever
   }

   printStruct(Nikki);

   // It's advantageous to pass arrays and structures by reference, 
   // because it's more efficient (don't need to make a copy of all data)
   // and allows you to modify the contents of the array or struct
   modifyStruct(&Nikki);

   printStruct(Nikki);

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe08(%rip), %rax       # 0x2081
movq %rax, -0x40(%rbp)
movl $0x13, -0x38(%rbp)
movss 0xd84(%rip), %xmm0      # 0x2010
movss %xmm0, -0x34(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0xa, -0x44(%rbp)
jge 0x12bb
movslq -0x44(%rbp), %rax
movss 0xd6a(%rip), %xmm0      # 0x2014
movss %xmm0, -0x30(%rbp,%rax,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1298
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups -0x20(%rbp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x1140
leaq -0x40(%rbp), %rdi
callq 0x1220
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups -0x20(%rbp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x1140
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_test_ctx_to_md_array
yapio_blk_md_t *
yapio_test_ctx_to_md_array(const yapio_test_ctx_t *ytc,
                           enum yapio_test_ctx_mdh_in_out in_out, int *num_ops)
{
    const yapio_test_ctx_md_t *ytcmh = &ytc->ytc_in_out_md_ops[in_out];

    if (num_ops)
        *num_ops = ytcmh->ytcmh_num_ops;

    yapio_blk_md_t *md_array = ytcmh->ytcmh_ops;

    return md_array;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
addq $0x68, %rax
movl -0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x252e
movq -0x20(%rsp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: main
int
main(int argc, char *argv[])
{
    yapio_init_available_io_modes();

    yapio_mpi_setup(argc, argv);

    yapio_getopts(argc, argv);

    yapio_assign_rank_to_group();

    yapio_verify_test_contexts(yapioMyTestGroup);

    yapio_io_mode_init();

    yapio_setup_buffers(yapioMyTestGroup);

    yapio_setup_test_file(yapioMyTestGroup);

    if (yapio_global_leader_rank())
        yapio_start_stats_collection_and_reporting_threads();

    if (yapioUseStoneWalling)
        yapio_stonewalling_thread_launch();

    yapio_mpi_barrier(MPI_COMM_WORLD);

    yapio_exec_all_tests();

    yapio_mpi_barrier(MPI_COMM_WORLD);

    yapio_close_test_file(yapioMyTestGroup);

    if (yapio_global_leader_rank())
        yapio_destroy_collection_and_reporting_threads();

    yapio_destroy_buffers();

    yapio_unlink_test_file();

    yapio_exit(yapio_io_mode_finalize());

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
callq 0x2630
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x2650
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x26a0
callq 0x2ad0
movq 0xccbe(%rip), %rdi      # 0xf250
callq 0x2be0
callq 0x2e80
movq 0xccad(%rip), %rdi      # 0xf250
callq 0x2e90
movq 0xcca1(%rip), %rdi      # 0xf250
callq 0x2eb0
callq 0x3720
testb $0x1, %al
jne 0x25bf
jmp 0x25c4
callq 0x3750
testb $0x1, 0xcc8d(%rip)      # 0xf258
je 0x25d2
callq 0x3890
movq 0xc9f7(%rip), %rdi      # 0xefd0
callq 0x3930
callq 0x3970
movq 0xc9e6(%rip), %rdi      # 0xefd0
callq 0x3930
movq 0xcc5a(%rip), %rdi      # 0xf250
callq 0x3cf0
callq 0x3720
testb $0x1, %al
jne 0x2606
jmp 0x260b
callq 0x3e10
callq 0x3e60
callq 0x3f50
callq 0x4140
movl %eax, %edi
callq 0x40f0
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_mpi_setup
static void
yapio_mpi_setup(int argc, char **argv)
{
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &yapioMyRank);
    MPI_Comm_size(MPI_COMM_WORLD, &yapioNumRanks);

    yapioMpiInit = true;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x14(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2110
movq 0xc95d(%rip), %rdi      # 0xefd0
leaq 0xcc16(%rip), %rsi      # 0xf290
callq 0x2250
movq 0xc94a(%rip), %rdi      # 0xefd0
leaq 0x20cc13(%rip), %rsi    # 0x20f2a0
callq 0x2180
movb $0x1, 0x20cc0b(%rip)    # 0x20f2a4
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_assign_rank_to_group
static void
yapio_assign_rank_to_group(void)
{
    int total_ranks;
    int i;
    for (i = 0, total_ranks = 0; i < yapioNumTestGroups; i++)
    {
        yapio_test_group_t *ytg = &yapioTestGroups[i];

        if (yapioMyRank < total_ranks + ytg->ytg_num_ranks)
        {
            yapioMyTestGroup = ytg;
            if (yapioMyRank == total_ranks)
                ytg->ytg_leader_rank = true;

            break;
        }

        total_ranks += ytg->ytg_num_ranks;
    }

    if (!yapioMyTestGroup)
        log_msg(YAPIO_LL_FATAL, "rank=%d was not assigned to test group",
                yapioMyRank);
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x20(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x20c7ce(%rip), %eax    # 0x20f2bc
jge 0x2b6d
movslq 0x20(%rsp), %rcx
leaq 0x20c7d4(%rip), %rax    # 0x20f2d0
imulq $0xc088, %rcx, %rcx     # imm = 0xC088
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0xc77f(%rip), %eax      # 0xf290
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %rdx
addl 0xb01c(%rdx), %ecx
cmpl %ecx, %eax
jge 0x2b4a
movq 0x18(%rsp), %rax
movq %rax, 0xc720(%rip)      # 0xf250
movl 0xc75a(%rip), %eax      # 0xf290
cmpl 0x24(%rsp), %eax
jne 0x2b48
movq 0x18(%rsp), %rax
movb $0x1, 0xb032(%rax)
jmp 0x2b6d
movq 0x18(%rsp), %rax
movl 0xb01c(%rax), %eax
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x2ae4
cmpq $0x0, 0xc6db(%rip)      # 0xf250
jne 0x2bd6
xorl %eax, %eax
cmpl 0xc691(%rip), %eax      # 0xf210
jg 0x2bd4
movq 0xc458(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
xorl %edi, %edi
callq 0x4890
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl 0xc6ea(%rip), %r8d      # 0xf290
movl 0xc6e4(%rip), %eax      # 0xf290
leaq 0x9316(%rip), %rsi      # 0xbec9
leaq 0x9345(%rip), %rcx      # 0xbeff
movl $0xa91, %r9d            # imm = 0xA91
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2370
movl $0x1, %edi
callq 0x40f0
jmp 0x2bd6
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_start_stats_collection_and_reporting_threads
static void
yapio_start_stats_collection_and_reporting_threads(void)
{
    if (pthread_create(&yapioStatsReportingThread, NULL,
                       yapio_stats_reporting, NULL))
        log_msg(YAPIO_LL_FATAL, "pthread_create: %s", strerror(errno));

    if (yapioNumTestGroups > 1)
    {
        /* This thread only starts if there are multiple test groups.
         */
        if (pthread_create(&yapioStatsCollectionThread, NULL,
                           yapio_stats_collection, NULL))
            log_msg(YAPIO_LL_FATAL, "pthread_create: %s", strerror(errno));
    }
}

// Assembly:
subq $0x38, %rsp
leaq 0xe173dd(%rip), %rdi    # 0xe1ab38
xorl %eax, %eax
movl %eax, %ecx
leaq 0x35aa(%rip), %rdx      # 0x6d10
movq %rcx, %rsi
callq 0x2140
cmpl $0x0, %eax
je 0x37e8
xorl %eax, %eax
cmpl 0xba95(%rip), %eax      # 0xf210
jg 0x37e6
movq 0xb85c(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
xorl %edi, %edi
callq 0x4890
movq %rax, 0x28(%rsp)
movl 0xbaf2(%rip), %eax      # 0xf290
movl %eax, 0x34(%rsp)
callq 0x2230
movl (%rax), %edi
callq 0x21e0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
movl 0x34(%rsp), %r8d
leaq 0x8b8d(%rip), %rsi      # 0xc351
leaq 0x8ba8(%rip), %rcx      # 0xc373
movl $0xb2f, %r9d            # imm = 0xB2F
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
movl $0x1, %edi
callq 0x40f0
jmp 0x37e8
cmpl $0x1, 0x20bacd(%rip)    # 0x20f2bc
jle 0x388b
leaq 0xe17344(%rip), %rdi    # 0xe1ab40
xorl %eax, %eax
movl %eax, %ecx
leaq 0x3619(%rip), %rdx      # 0x6e20
movq %rcx, %rsi
callq 0x2140
cmpl $0x0, %eax
je 0x3889
xorl %eax, %eax
cmpl 0xb9f4(%rip), %eax      # 0xf210
jg 0x3887
movq 0xb7bb(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
xorl %edi, %edi
callq 0x4890
movq %rax, 0x10(%rsp)
movl 0xba51(%rip), %eax      # 0xf290
movl %eax, 0x1c(%rsp)
callq 0x2230
movl (%rax), %edi
callq 0x21e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl 0x1c(%rsp), %r8d
leaq 0x8aec(%rip), %rsi      # 0xc351
leaq 0x8b07(%rip), %rcx      # 0xc373
movl $0xb37, %r9d            # imm = 0xB37
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
movl $0x1, %edi
callq 0x40f0
jmp 0x3889
jmp 0x388b
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_mpi_barrier
static int
yapio_mpi_barrier(MPI_Comm comm)
{
    int rc;

    MPI_OP_START;
    rc = MPI_Barrier(comm);
    MPI_OP_END;

    return rc;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0xe161b8(%rip), %rdi    # 0xe19af8
callq 0x2350
movq 0x10(%rsp), %rdi
callq 0x2030
movl %eax, 0xc(%rsp)
leaq 0xe1619e(%rip), %rdi    # 0xe19af8
callq 0x2390
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_close_test_file
static void
yapio_close_test_file(const yapio_test_group_t *ytg)
{
    int rc;

    if (ytg->ytg_file_per_process)
    {
        int i;
        for (i = 0; i < ytg->ytg_num_ranks; i++)
        {
            if (yapioFileDescFpp[i] >= 0)
            {
                rc = YAPIO_SYS_CALL(close)(yapioFileDescFpp[i]);
                if (rc < 0)
                    break;
            }
        }
    }
    else
    {
        rc = YAPIO_SYS_CALL(close)(yapioFileDesc);
    }

    if (rc < 0)
        log_msg(YAPIO_LL_FATAL, "close: %s", strerror(errno));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
testb $0x1, 0xb030(%rax)
je 0x3d6e
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0xb01c(%rcx), %eax
jge 0x3d6c
movq 0xe15df9(%rip), %rax    # 0xe19b20
movslq 0x28(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x3d5d
movq 0xb4cf(%rip), %rax      # 0xf208
movq 0x8(%rax), %rax
movq 0xe15ddc(%rip), %rcx    # 0xe19b20
movslq 0x28(%rsp), %rdx
movl (%rcx,%rdx,4), %edi
callq *%rax
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jge 0x3d5b
jmp 0x3d6c
jmp 0x3d5d
jmp 0x3d5f
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x3d0f
jmp 0x3d85
movq 0xb493(%rip), %rax      # 0xf208
movq 0x8(%rax), %rax
movl 0xe15d75(%rip), %edi    # 0xe19af4
callq *%rax
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jge 0x3e01
xorl %eax, %eax
cmpl 0xb47c(%rip), %eax      # 0xf210
jg 0x3dff
movq 0xb243(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
xorl %edi, %edi
callq 0x4890
movq %rax, 0x18(%rsp)
movl 0xb4d9(%rip), %eax      # 0xf290
movl %eax, 0x24(%rsp)
callq 0x2230
movl (%rax), %edi
callq 0x21e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl 0x24(%rsp), %r8d
leaq 0x8fec(%rip), %rsi      # 0xcdc9
leaq 0x8ffe(%rip), %rcx      # 0xcde2
movl $0x556, %r9d            # imm = 0x556
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
movl $0x1, %edi
callq 0x40f0
jmp 0x3e01
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_destroy_collection_and_reporting_threads
static void
yapio_destroy_collection_and_reporting_threads(void)
{
    pthread_join(yapioStatsReportingThread, NULL);

    if (yapioUseStoneWalling)
        pthread_join(yapioStoneWallThread, NULL);

    if (yapioNumTestGroups > 1)
        pthread_join(yapioStatsCollectionThread, NULL);
}

// Assembly:
pushq %rax
movq 0xe16d20(%rip), %rdi    # 0xe1ab38
xorl %eax, %eax
movl %eax, %esi
callq 0x2040
testb $0x1, 0xb430(%rip)      # 0xf258
je 0x3e3a
movq 0xe16d4f(%rip), %rdi    # 0xe1ab80
xorl %eax, %eax
movl %eax, %esi
callq 0x2040
cmpl $0x1, 0x20b47b(%rip)    # 0x20f2bc
jle 0x3e53
movq 0xe16cf6(%rip), %rdi    # 0xe1ab40
xorl %eax, %eax
movl %eax, %esi
callq 0x2040
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_destroy_buffers
static void
yapio_destroy_buffers(void)
{
    if (yapioSourceBlkMd)
        YAPIO_FREE(yapioSourceBlkMd);

    if (yapioIOBuf)
        YAPIO_FREE(yapioIOBuf);
}

// Assembly:
subq $0x18, %rsp
cmpq $0x0, 0xb3f4(%rip)      # 0xf260
je 0x3ed7
movq 0xb3eb(%rip), %rdi      # 0xf260
callq 0x2150
movl $0x3, %eax
cmpl 0xb38b(%rip), %eax      # 0xf210
jg 0x3ed5
movq 0xb152(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl 0xb3e1(%rip), %r8d      # 0xf290
movq 0xb3aa(%rip), %rax      # 0xf260
leaq 0x7faf(%rip), %rsi      # 0xbe6c
leaq 0x8f34(%rip), %rcx      # 0xcdf8
movl $0x55d, %r9d            # imm = 0x55D
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
jmp 0x3ed7
cmpq $0x0, 0xe13bf1(%rip)    # 0xe17ad0
je 0x3f4a
movq 0xe13be8(%rip), %rdi    # 0xe17ad0
callq 0x2150
movl $0x3, %eax
cmpl 0xb318(%rip), %eax      # 0xf210
jg 0x3f48
movq 0xb0df(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl 0xb36e(%rip), %r8d      # 0xf290
movq 0xe13ba7(%rip), %rax    # 0xe17ad0
leaq 0x7f3c(%rip), %rsi      # 0xbe6c
leaq 0x8ec1(%rip), %rcx      # 0xcdf8
movl $0x560, %r9d            # imm = 0x560
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
jmp 0x3f4a
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_unlink_test_file
static void
yapio_unlink_test_file(void)
{
    const yapio_test_group_t *ytg = yapioMyTestGroup;
    bool fpp = ytg->ytg_file_per_process;

    const char *unlink_fn = fpp ? yapioTestFileNameFpp : yapioTestFileName;
    log_msg(YAPIO_LL_DEBUG, "%s keep=%d", unlink_fn, ytg->ytg_keep_file);

    if (ytg->ytg_keep_file || (!fpp && !yapio_leader_rank()))
        return;

    int rc = YAPIO_SYS_CALL(unlink)(unlink_fn);
    if (rc)
    {
        log_msg(YAPIO_LL_ERROR, "unlink %s: %s", unlink_fn, strerror(errno));

        yapio_exit(YAPIO_EXIT_ERR);
    }

    /* If the Metadata restart file is present then remove it too.
     */
    if (yapioRestartFileName[0] == '/')
        YAPIO_SYS_CALL(unlink)(yapioRestartFileName);
}

// Assembly:
subq $0x58, %rsp
movq 0xb2f5(%rip), %rax      # 0xf250
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movb 0xb030(%rax), %al
andb $0x1, %al
movb %al, 0x4f(%rsp)
movb 0x4f(%rsp), %dl
leaq 0xe14b74(%rip), %rax    # 0xe18af0
leaq 0xe15bad(%rip), %rcx    # 0xe19b30
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x40(%rsp)
movl $0x3, %eax
cmpl 0xb276(%rip), %eax      # 0xf210
jg 0x3ffc
movq 0xb03d(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x30(%rsp), %rdi
movq %rax, %rdx
movl 0xb2cc(%rip), %r8d      # 0xf290
movq 0x40(%rsp), %r10
movq 0x50(%rsp), %rax
movb 0xb031(%rax), %al
andb $0x1, %al
movzbl %al, %eax
leaq 0x8e2e(%rip), %rsi      # 0xce0e
leaq 0x8e41(%rip), %rcx      # 0xce28
movl $0x701, %r9d            # imm = 0x701
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
movq 0x50(%rsp), %rax
testb $0x1, 0xb031(%rax)
jne 0x401a
testb $0x1, 0x4f(%rsp)
jne 0x401f
callq 0x5910
testb $0x1, %al
jne 0x401f
jmp 0x40ea
movq 0xb1e2(%rip), %rax      # 0xf208
movq 0x18(%rax), %rax
movq 0x40(%rsp), %rdi
callq *%rax
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0x40cd
movl $0x1, %eax
cmpl 0xb1c5(%rip), %eax      # 0xf210
jg 0x40c3
movq 0xaf8c(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x1, %edi
callq 0x4890
movq %rax, 0x18(%rsp)
movl 0xb21f(%rip), %eax      # 0xf290
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x2230
movl (%rax), %edi
callq 0x21e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl 0x24(%rsp), %r8d
movq 0x28(%rsp), %r10
leaq 0x8d99(%rip), %rsi      # 0xce3f
leaq 0x8d7b(%rip), %rcx      # 0xce28
movl $0x709, %r9d            # imm = 0x709
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
movl $0x1, %edi
callq 0x40f0
movsbl 0xe13a0c(%rip), %eax    # 0xe17ae0
cmpl $0x2f, %eax
jne 0x40ea
movq 0xb128(%rip), %rax      # 0xf208
leaq 0xe139f9(%rip), %rdi    # 0xe17ae0
callq *0x18(%rax)
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_exit
static void
yapio_exit(int exit_rc)
{
    if (yapioMpiInit)
    {
        yapio_mpi_barrier(MPI_COMM_WORLD);

        if (yapioIOErrorCnt)
            MPI_Abort(MPI_COMM_WORLD, -EIO);

        else
            MPI_Finalize();
    }

    exit(exit_rc);
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
testb $0x1, 0x20b1a8(%rip)    # 0x20f2a4
je 0x412d
movq 0xaecb(%rip), %rdi      # 0xefd0
callq 0x3930
cmpl $0x0, 0xe16a7b(%rip)    # 0xe1ab8c
je 0x4126
movq 0xaeb6(%rip), %rdi      # 0xefd0
movl $0xfffffffb, %esi       # imm = 0xFFFFFFFB
callq 0x21c0
jmp 0x412b
callq 0x2290
jmp 0x412d
movl 0x4(%rsp), %edi
callq 0x20c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_mmap_close
static int
yapio_mmap_close(int fd)
{
    log_msg(YAPIO_LL_DEBUG, "fd=%d addr=%p", fd, yapioFdMap[fd].yfm_addr);

    size_t len = (yapioMyTestGroup->ytg_num_blks_per_rank *
                  yapioMyTestGroup->ytg_blk_sz);

    int rc = munmap(yapioFdMap[fd].yfm_addr, len);
    if (rc)
        log_msg(YAPIO_LL_ERROR, "munmap(): %s", strerror(errno));

    rc = close(yapioFdMap[fd].yfm_fd);
    if (rc)
        log_msg(YAPIO_LL_ERROR, "close(): %s", strerror(errno));

    return rc;
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movl $0x3, %eax
cmpl 0xadbd(%rip), %eax      # 0xf210
jg 0x44bd
movq 0xab84(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x48(%rsp), %rdi
movq %rax, %rdx
movl 0xae13(%rip), %r8d      # 0xf290
movl 0x64(%rsp), %r10d
movslq 0x64(%rsp), %rcx
leaq 0xae12(%rip), %rax      # 0xf2a0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
leaq 0x6ef3(%rip), %rsi      # 0xb393
leaq 0x6f09(%rip), %rcx      # 0xb3b0
movl $0x1b8, %r9d            # imm = 0x1B8
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
movq 0xad8c(%rip), %rax      # 0xf250
movq 0xb020(%rax), %rax
movq 0xad7e(%rip), %rcx      # 0xf250
imulq 0xb028(%rcx), %rax
movq %rax, 0x58(%rsp)
movslq 0x64(%rsp), %rcx
leaq 0xadb5(%rip), %rax      # 0xf2a0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq 0x58(%rsp), %rsi
callq 0x22d0
movl %eax, 0x54(%rsp)
cmpl $0x0, 0x54(%rsp)
je 0x457c
movl $0x1, %eax
cmpl 0xacfa(%rip), %eax      # 0xf210
jg 0x457a
movq 0xaac1(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x1, %edi
callq 0x4890
movq %rax, 0x38(%rsp)
movl 0xad54(%rip), %eax      # 0xf290
movl %eax, 0x44(%rsp)
callq 0x2230
movl (%rax), %edi
callq 0x21e0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rdx
movl 0x44(%rsp), %r8d
leaq 0x6e5f(%rip), %rsi      # 0xb3c1
leaq 0x6e47(%rip), %rcx      # 0xb3b0
movl $0x1bf, %r9d            # imm = 0x1BF
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
jmp 0x457c
movslq 0x64(%rsp), %rcx
leaq 0xad18(%rip), %rax      # 0xf2a0
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
callq 0x2080
movl %eax, 0x54(%rsp)
cmpl $0x0, 0x54(%rsp)
je 0x4612
movl $0x1, %eax
cmpl 0xac64(%rip), %eax      # 0xf210
jg 0x4610
movq 0xaa2b(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x1, %edi
callq 0x4890
movq %rax, 0x20(%rsp)
movl 0xacbe(%rip), %eax      # 0xf290
movl %eax, 0x2c(%rsp)
callq 0x2230
movl (%rax), %edi
callq 0x21e0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl 0x2c(%rsp), %r8d
leaq 0x6de5(%rip), %rsi      # 0xb3dd
leaq 0x6db1(%rip), %rcx      # 0xb3b0
movl $0x1c3, %r9d            # imm = 0x1C3
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
jmp 0x4612
movl 0x54(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_mmap_fsync
static int
yapio_mmap_fsync(int fd)
{
#if 1
    size_t len = (yapioMyTestGroup->ytg_num_blks_per_rank *
                  yapioMyTestGroup->ytg_blk_sz *
                  (yapioMyTestGroup->ytg_file_per_process ?
                   1 : yapioMyTestGroup->ytg_num_ranks));

    int rc = msync(yapioFdMap[fd].yfm_addr, len, MS_SYNC);
    if (rc)
    {
        rc = -errno;

        log_msg(YAPIO_LL_WARN, "fd=%d addr=%p rc=%d",
                fd, yapioFdMap[fd].yfm_addr, rc);
    }
#else
    int rc = fsync(fd);
#endif
    return rc;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq 0xac21(%rip), %rax      # 0xf250
movq 0xb020(%rax), %rax
movq 0xac13(%rip), %rcx      # 0xf250
imulq 0xb028(%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0xabff(%rip), %rax      # 0xf250
testb $0x1, 0xb030(%rax)
je 0x4665
movl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4676
movq 0xabe4(%rip), %rax      # 0xf250
movl 0xb01c(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
movslq %ecx, %rcx
imulq %rcx, %rax
movq %rax, 0x38(%rsp)
movslq 0x44(%rsp), %rcx
leaq 0xac09(%rip), %rax      # 0xf2a0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq 0x38(%rsp), %rsi
movl $0x4, %edx
callq 0x21a0
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x474f
callq 0x2230
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, 0x34(%rsp)
movl $0x2, %eax
cmpl 0xab35(%rip), %eax      # 0xf210
jg 0x474d
movq 0xa8fc(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x2, %edi
callq 0x4890
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movl 0xab8b(%rip), %r8d      # 0xf290
movl 0x44(%rsp), %r11d
movslq 0x44(%rsp), %rcx
leaq 0xab8a(%rip), %rax      # 0xf2a0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %r10
movl 0x34(%rsp), %eax
leaq 0x6ccc(%rip), %rsi      # 0xb3f8
leaq 0x6ce8(%rip), %rcx      # 0xb41b
movl $0x1d7, %r9d            # imm = 0x1D7
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x2370
jmp 0x474f
movl 0x34(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_mmap_pwrite
static ssize_t
yapio_mmap_pwrite(int fd, const void *buf, size_t count, off_t offset)
{
    char *addr = yapioFdMap[fd].yfm_addr;

    log_msg(YAPIO_LL_DEBUG, "%p off=%ld cnt=%zd",
            &addr[offset], offset, count);

    memcpy(&addr[offset], (char *)buf, count);

    return count;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movslq 0x44(%rsp), %rcx
leaq 0xaabd(%rip), %rax      # 0xf2a0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x3, %eax
cmpl 0xaa12(%rip), %eax      # 0xf210
jg 0x4865
movq 0xa7d9(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movl 0xaa68(%rip), %r8d      # 0xf290
movq 0x20(%rsp), %r11
addq 0x28(%rsp), %r11
movq 0x28(%rsp), %r10
movq 0x30(%rsp), %rax
leaq 0x6be9(%rip), %rsi      # 0xb42c
leaq 0x6c04(%rip), %rcx      # 0xb44e
movl $0x1ef, %r9d            # imm = 0x1EF
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x2370
movq 0x20(%rsp), %rdi
addq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x23a0
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_ll_to_string
static const char *
yapio_ll_to_string(enum yapio_log_levels yapio_ll)
{
    switch (yapio_ll)
    {
    case YAPIO_LL_FATAL:
        return "fatal";
    case YAPIO_LL_ERROR:
        return "error";
    case YAPIO_LL_WARN:
        return "warn";
    case YAPIO_LL_TRACE:
        return "trace";
    default:
        break;
    }

    return "debug";
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x4, %rax
ja 0x48f0
movq -0x18(%rsp), %rax
leaq 0x6825(%rip), %rcx      # 0xb0d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6ab7(%rip), %rax      # 0xb376
movq %rax, -0x8(%rsp)
jmp 0x48fe
leaq 0x6aaf(%rip), %rax      # 0xb37c
movq %rax, -0x8(%rsp)
jmp 0x48fe
leaq 0x6aa7(%rip), %rax      # 0xb382
movq %rax, -0x8(%rsp)
jmp 0x48fe
leaq 0x6a9e(%rip), %rax      # 0xb387
movq %rax, -0x8(%rsp)
jmp 0x48fe
jmp 0x48f2
leaq 0x6a94(%rip), %rax      # 0xb38d
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_parse_io_mode
static const yapio_io_syscall_ops_t *
yapio_parse_io_mode(const char *io_mode_str)
{
    if (strnlen(io_mode_str, 2) > 1)
        return NULL;

    switch (io_mode_str[0])
    {
    case 'P':
        return yapio_io_modes[YAPIO_IO_MODE_DEFAULT];

    case 'I':
        yapioModeCurrent = YAPIO_IO_MODE_IME;
        yapioTestFileNamePrefix = "ime://";
        return yapio_io_modes[YAPIO_IO_MODE_IME];

    case 'M':
        yapioModeCurrent = YAPIO_IO_MODE_MPIIO;
        yapioTestFileNamePrefix = "XXX://";
        return yapio_io_modes[YAPIO_IO_MODE_MPIIO];

    case 'm':
        yapioModeCurrent = YAPIO_IO_MODE_MMAP;
        return yapio_io_modes[YAPIO_IO_MODE_MMAP];

    default:
        return NULL;
    }

    return NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x2130
cmpq $0x1, %rax
jbe 0x499c
movq $0x0, 0x10(%rsp)
jmp 0x4a45
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
addl $-0x49, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x24, %eax
ja 0x4a3c
movq (%rsp), %rax
leaq 0x6727(%rip), %rcx      # 0xb0e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0xa89f(%rip), %rax      # 0xf270
movq %rax, 0x10(%rsp)
jmp 0x4a45
movl $0x1, 0x20a8e6(%rip)    # 0x20f2c8
leaq 0x70d0(%rip), %rax      # 0xbab9
movq %rax, 0xa840(%rip)      # 0xf230
movq 0xa881(%rip), %rax      # 0xf278
movq %rax, 0x10(%rsp)
jmp 0x4a45
movl $0x2, 0x20a8c0(%rip)    # 0x20f2c8
leaq 0x70b1(%rip), %rax      # 0xbac0
movq %rax, 0xa81a(%rip)      # 0xf230
movq 0xa863(%rip), %rax      # 0xf280
movq %rax, 0x10(%rsp)
jmp 0x4a45
movl $0x3, 0x20a89a(%rip)    # 0x20f2c8
movq 0xa853(%rip), %rax      # 0xf288
movq %rax, 0x10(%rsp)
jmp 0x4a45
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_test_group_init
static void
yapio_test_group_init(yapio_test_group_t *ytg)
{
    ytg->ytg_num_contexts = 1;
    ytg->ytg_num_blks_per_rank = yapioNumBlksPerRank;
    ytg->ytg_blk_sz = yapioBlkSz;
    ytg->ytg_file_per_process = false;
    ytg->ytg_restart_from_previous_job = false;
    ytg->ytg_group_num = yapioNumTestGroups;
    strncpy(ytg->ytg_prefix, YAPIO_DEFAULT_FILE_PREFIX,
            YAPIO_RECIPE_PARAM_STRLEN_MAX);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl $0x1, 0xb010(%rax)
movq 0x9afe(%rip), %rcx      # 0xf228
movq (%rsp), %rax
movq %rcx, 0xb020(%rax)
movq 0x9adc(%rip), %rcx      # 0xf218
movq (%rsp), %rax
movq %rcx, 0xb028(%rax)
movq (%rsp), %rax
movb $0x0, 0xb030(%rax)
movq (%rsp), %rax
movb $0x0, 0xb033(%rax)
movl 0x209b59(%rip), %ecx    # 0x20f2bc
movq (%rsp), %rax
movl %ecx, 0xb014(%rax)
movq (%rsp), %rdi
addq $0xb03f, %rdi           # imm = 0xB03F
leaq 0x6525(%rip), %rsi      # 0xbca4
movl $0x41, %edx
callq 0x2310
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_test_recipe_param_to_string
static int
yapio_test_recipe_param_to_string(const char *param_str, char *dest)
{
    char recipe_param_tmp_str[YAPIO_RECIPE_PARAM_STRLEN_MAX];

    int len = yapio_test_recipe_param_gather(param_str, recipe_param_tmp_str);

    strncpy(dest, recipe_param_tmp_str, len);

    log_msg_r0(YAPIO_LL_DEBUG, "%s", dest);

    return len;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5950
movl %eax, 0x1c(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movslq 0x1c(%rsp), %rdx
callq 0x2310
callq 0x5910
testb $0x1, %al
jne 0x57d0
jmp 0x582b
movl $0x3, %eax
cmpl 0x9a35(%rip), %eax      # 0xf210
jg 0x5829
movq 0x97fc(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl 0x9a8b(%rip), %r8d      # 0xf290
movq 0x68(%rsp), %rax
leaq 0x649a(%rip), %rsi      # 0xbcab
leaq 0x64a5(%rip), %rcx      # 0xbcbd
movl $0x298, %r9d            # imm = 0x298
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
jmp 0x582b
movl 0x1c(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_test_recipe_param_to_ull
static int
yapio_test_recipe_param_to_ull(const char *param_str, size_t *result)
{
    char recipe_param_tmp_str[YAPIO_RECIPE_PARAM_STRLEN_MAX];

    int len = yapio_test_recipe_param_gather(param_str, recipe_param_tmp_str);

    if (result)
        *result = strtoull(recipe_param_tmp_str, NULL, 10);

    log_msg_r0(YAPIO_LL_DEBUG, "%s %zu", recipe_param_tmp_str, *result);

    return len;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5950
movl %eax, 0x1c(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x5887
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x2320
movq %rax, %rcx
movq 0x68(%rsp), %rax
movq %rcx, (%rax)
callq 0x5910
testb $0x1, %al
jne 0x5892
jmp 0x58fa
movl $0x3, %eax
cmpl 0x9973(%rip), %eax      # 0xf210
jg 0x58f8
movq 0x973a(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl 0x99c9(%rip), %r8d      # 0xf290
leaq 0x20(%rsp), %r10
movq 0x68(%rsp), %rax
movq (%rax), %rax
leaq 0x6423(%rip), %rsi      # 0xbcfe
leaq 0x6432(%rip), %rcx      # 0xbd14
movl $0x28a, %r9d            # imm = 0x28A
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
jmp 0x58fa
movl 0x1c(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_test_recipe_param_gather
static int
yapio_test_recipe_param_gather(const char *param_str, char *buf)
{
    int j;

    for (j = 0; j < YAPIO_RECIPE_PARAM_STRLEN_MAX - 1 && param_str[j] != ':';
         j++)
        buf[j] = param_str[j];

    if (param_str[j] != ':')
    {
        if (j == YAPIO_RECIPE_PARAM_STRLEN_MAX)
        {
            log_msg(YAPIO_LL_ERROR, "recipe input string is too long");
            return -E2BIG;
        }
        return -EINVAL;
    }

    buf[j] = '\0';

    return j + 1; //include ':' char
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
xorl %eax, %eax
cmpl $0x40, 0xc(%rsp)
movb %al, 0xb(%rsp)
jge 0x598b
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x5995
jmp 0x59bc
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5966
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
je 0x5a38
cmpl $0x41, 0xc(%rsp)
jne 0x5a2e
movl $0x1, %eax
cmpl 0x982f(%rip), %eax      # 0xf210
jg 0x5a24
movq 0x95f6(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, (%rsp)
movl $0x1, %edi
callq 0x4890
movq (%rsp), %rdi
movq %rax, %rdx
movl 0x9887(%rip), %r8d      # 0xf290
leaq 0x60b7(%rip), %rsi      # 0xbac7
leaq 0x62c8(%rip), %rcx      # 0xbcdf
movl $0x275, %r9d            # imm = 0x275
movb $0x0, %al
callq 0x2370
movl $0xfffffff9, 0x24(%rsp) # imm = 0xFFFFFFF9
jmp 0x5a51
movl $0xffffffea, 0x24(%rsp) # imm = 0xFFFFFFEA
jmp 0x5a51
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_alloc_buffers
static void
yapio_alloc_buffers(const yapio_test_group_t *ytg)
{
    yapioSourceBlkMd = YAPIO_CALLOC(ytg->ytg_num_blks_per_rank,
                                    sizeof(yapio_blk_md_t));
    if (yapioSourceBlkMd == NULL)
        yapio_destroy_buffers_and_abort();

    yapioIOBuf = YAPIO_CALLOC(1, ytg->ytg_blk_sz);
    if (yapioIOBuf == NULL)
        yapio_destroy_buffers_and_abort();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0xb020(%rax), %rdi
movl $0x10, %esi
callq 0x22c0
movq %rax, 0x38(%rsp)
movl $0x3, %eax
cmpl 0x9461(%rip), %eax      # 0xf210
jg 0x5e12
movq 0x9228(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movl 0x94b7(%rip), %r8d      # 0xf290
movq 0x38(%rsp), %r10
movq 0x40(%rsp), %rax
movq 0xb020(%rax), %rax
shlq $0x4, %rax
leaq 0x605a(%rip), %rsi      # 0xbe4f
leaq 0x6214(%rip), %rcx      # 0xc010
movl $0x56e, %r9d            # imm = 0x56E
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x9438(%rip)      # 0xf260
cmpq $0x0, 0x9430(%rip)      # 0xf260
jne 0x5e37
callq 0x6050
movq 0x40(%rsp), %rax
movq 0xb028(%rax), %rsi
movl $0x1, %edi
callq 0x22c0
movq %rax, 0x28(%rsp)
movl $0x3, %eax
cmpl 0x93b3(%rip), %eax      # 0xf210
jg 0x5ec0
movq 0x917a(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl 0x9409(%rip), %r8d      # 0xf290
movq 0x28(%rsp), %r10
movq 0x40(%rsp), %rax
movq 0xb028(%rax), %rax
shlq $0x0, %rax
leaq 0x5fac(%rip), %rsi      # 0xbe4f
leaq 0x6166(%rip), %rcx      # 0xc010
movl $0x572, %r9d            # imm = 0x572
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0xe11bfa(%rip)    # 0xe17ad0
cmpq $0x0, 0xe11bf2(%rip)    # 0xe17ad0
jne 0x5ee5
callq 0x6050
addq $0x48, %rsp
retq
nopw (%rax,%rax)