LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_initialize_source_md_buffer
static void
yapio_initialize_source_md_buffer(const yapio_test_group_t *ytg)
{
    if (ytg->ytg_restart_from_previous_job)
        return yapio_initialize_source_md_buffer_from_file(ytg);

    int rel_rank = yapio_relative_rank_get(ytg, 0);
    size_t i;

    for (i = 0; i < ytg->ytg_num_blks_per_rank; i++)
    {
        yapioSourceBlkMd[i].ybm_writer_rank = yapioMyRank;

        yapioSourceBlkMd[i].ybm_blk_number = ytg->ytg_file_per_process ? i :
            rel_rank * ytg->ytg_num_blks_per_rank + i;

        yapioSourceBlkMd[i].ybm_owner_rank_fpp =
            ytg->ytg_file_per_process ? rel_rank : 0;

        yapioSourceBlkMd[i].ybm_not_hole = 0;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0xb033(%rax)
je 0x5f16
movq 0x20(%rsp), %rdi
callq 0x60d0
jmp 0x604a
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x61d0
movl %eax, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0xb020(%rcx), %rax
jae 0x604a
movl 0x9344(%rip), %ecx      # 0xf290
movq 0x930d(%rip), %rax      # 0xf260
movq 0x10(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
testb $0x1, 0xb030(%rax)
je 0x5f7b
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x5f97
movslq 0x1c(%rsp), %rax
movq 0x20(%rsp), %rcx
imulq 0xb020(%rcx), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdx
movq 0x92bd(%rip), %rax      # 0xf260
movq 0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movabsq $0x3fffffffffffffff, %rsi # imm = 0x3FFFFFFFFFFFFFFF
andq %rsi, %rdx
movabsq $-0x4000000000000000, %rsi # imm = 0xC000000000000000
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
testb $0x1, 0xb030(%rax)
je 0x5fec
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x5ff4
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x5ff4
movl 0x4(%rsp), %ecx
movq 0x9261(%rip), %rax      # 0xf260
movq 0x10(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq 0x924b(%rip), %rax      # 0xf260
movq 0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movabsq $-0x4000000000000001, %rcx # imm = 0xBFFFFFFFFFFFFFFF
andq 0x8(%rax), %rcx
orq $0x0, %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x5f2f
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_initialize_source_md_buffer_from_file
static void
yapio_initialize_source_md_buffer_from_file(const yapio_test_group_t *ytg)
{
    if (yapio_md_buffer_io(ytg, false))
        log_msg(YAPIO_LL_FATAL, "yapio_md_buffer_io() failed");

    /* rank 0 makes sure each rank can read its md file */
    int n = 1;
    int global_sum = 0;
    MPI_Reduce(&n, &global_sum, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
    if (yapioMyRank == 0 && global_sum != yapioNumRanks)
    {
        printf("%d rank(s) unable to open metadata file\n",
               yapioNumRanks - global_sum);
        /* stop execution for all ranks */
        MPI_Abort(MPI_COMM_WORLD, 1);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x6230
cmpl $0x0, %eax
je 0x6140
xorl %eax, %eax
cmpl 0x911e(%rip), %eax      # 0xf210
jg 0x613e
movq 0x8ee5(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
xorl %edi, %edi
callq 0x4890
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl 0x9177(%rip), %r8d      # 0xf290
leaq 0x5f4c(%rip), %rsi      # 0xc06c
leaq 0x5f70(%rip), %rcx      # 0xc097
movl $0x5e4, %r9d            # imm = 0x5E4
movb $0x0, %al
callq 0x2370
movl $0x1, %edi
callq 0x40f0
jmp 0x6140
movl $0x1, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
leaq 0x1c(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movl $0x1, %edx
movq 0x8e3a(%rip), %rcx      # 0xefa0
movq 0x8e6b(%rip), %r8       # 0xefd8
xorl %r9d, %r9d
movq 0x8e59(%rip), %rax      # 0xefd0
movq %rax, (%rsp)
callq 0x2280
cmpl $0x0, 0x9109(%rip)      # 0xf290
jne 0x61be
movl 0x18(%rsp), %eax
cmpl 0x20910d(%rip), %eax    # 0x20f2a0
je 0x61be
movl 0x209105(%rip), %esi    # 0x20f2a0
subl 0x18(%rsp), %esi
leaq 0x5f1d(%rip), %rdi      # 0xc0c3
movb $0x0, %al
callq 0x2060
movq 0x8e1c(%rip), %rdi      # 0xefd0
movl $0x1, %esi
callq 0x21c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_verify_test_directory
static void
yapio_verify_test_directory(void)
{
    int rc = mkdir(yapioTestRootDir, 0740);
    if (rc == 0)
        return;

    if (errno != EEXIST)
        log_msg(YAPIO_LL_FATAL, "mkdir(%s):  %s", yapioTestRootDir,
                strerror(errno));

    struct stat stb;
    rc = stat(yapioTestRootDir, &stb);
    if (rc)
        rc = errno;

    else if (!S_ISDIR(stb.st_mode))
        rc = ENOTDIR;

    if (rc)
        log_msg(YAPIO_LL_FATAL, "%s:  %s", yapioTestRootDir, strerror(rc));
}

// Assembly:
subq $0xe8, %rsp
movq 0x208b12(%rip), %rdi    # 0x20f2c0
movl $0x1e0, %esi            # imm = 0x1E0
callq 0x23d0
movl %eax, 0xe4(%rsp)
cmpl $0x0, 0xe4(%rsp)
jne 0x67ce
jmp 0x694f
callq 0x2230
cmpl $0x11, (%rax)
je 0x6867
xorl %eax, %eax
cmpl 0x8a2c(%rip), %eax      # 0xf210
jg 0x6865
movq 0x87f3(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x30(%rsp)
xorl %edi, %edi
callq 0x4890
movq %rax, 0x38(%rsp)
movl 0x8a89(%rip), %eax      # 0xf290
movl %eax, 0x44(%rsp)
movq 0x208aae(%rip), %rax    # 0x20f2c0
movq %rax, 0x48(%rsp)
callq 0x2230
movl (%rax), %edi
callq 0x21e0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rdx
movl 0x44(%rsp), %r8d
movq 0x48(%rsp), %r10
leaq 0x5a75(%rip), %rsi      # 0xc2b3
leaq 0x5a8c(%rip), %rcx      # 0xc2d1
movl $0x476, %r9d            # imm = 0x476
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
movl $0x1, %edi
callq 0x40f0
jmp 0x6867
movq 0x208a52(%rip), %rdi    # 0x20f2c0
leaq 0x50(%rsp), %rsi
callq 0x2380
movl %eax, 0xe4(%rsp)
cmpl $0x0, 0xe4(%rsp)
je 0x6899
callq 0x2230
movl (%rax), %eax
movl %eax, 0xe4(%rsp)
jmp 0x68b6
movl 0x68(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
je 0x68b4
movl $0x14, 0xe4(%rsp)
jmp 0x68b6
cmpl $0x0, 0xe4(%rsp)
je 0x694f
xorl %eax, %eax
cmpl 0x8944(%rip), %eax      # 0xf210
jg 0x694d
movq 0x870b(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
xorl %edi, %edi
callq 0x4890
movq %rax, 0x18(%rsp)
movl 0x89a1(%rip), %eax      # 0xf290
movl %eax, 0x24(%rsp)
movq 0x2089c6(%rip), %rax    # 0x20f2c0
movq %rax, 0x28(%rsp)
movl 0xe4(%rsp), %edi
callq 0x21e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl 0x24(%rsp), %r8d
movq 0x28(%rsp), %r10
leaq 0x59c7(%rip), %rsi      # 0xc2ed
leaq 0x59a4(%rip), %rcx      # 0xc2d1
movl $0x481, %r9d            # imm = 0x481
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
movl $0x1, %edi
callq 0x40f0
jmp 0x694f
addq $0xe8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_make_filename
static int
yapio_make_filename(char *file_name, int rank)
{
    int rc = rank >= 0 ?
        snprintf(file_name, PATH_MAX, "%s%s.%d",
                 yapioTestFileNamePrefix, yapioTestFileName, rank) :
        snprintf(file_name, PATH_MAX, "%s%s",
                 yapioTestFileNamePrefix, yapioTestFileName);

    if (rc > PATH_MAX)
    {
        log_msg(YAPIO_LL_ERROR, "%s", strerror(ENAMETOOLONG));
        return -ENAMETOOLONG;
    }

    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jl 0x6c45
movq 0x28(%rsp), %rdi
movq 0x8610(%rip), %rcx      # 0xf230
movl 0x24(%rsp), %r9d
movl $0x1000, %esi           # imm = 0x1000
leaq 0x5704(%rip), %rdx      # 0xc335
leaq 0xe11eb8(%rip), %r8     # 0xe18af0
movb $0x0, %al
callq 0x2070
movl %eax, 0x1c(%rsp)
jmp 0x6c6f
movq 0x28(%rsp), %rdi
movq 0x85df(%rip), %rcx      # 0xf230
movl $0x1000, %esi           # imm = 0x1000
leaq 0x556c(%rip), %rdx      # 0xc1c9
leaq 0xe11e8c(%rip), %r8     # 0xe18af0
movb $0x0, %al
callq 0x2070
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x20(%rsp)
cmpl $0x1000, 0x20(%rsp)     # imm = 0x1000
jle 0x6cf8
movl $0x1, %eax
cmpl 0x8584(%rip), %eax      # 0xf210
jg 0x6cee
movq 0x834b(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %edi
callq 0x4890
movq %rax, 0x10(%rsp)
movl 0x85de(%rip), %eax      # 0xf290
movl %eax, 0x18(%rsp)
movl $0x24, %edi
callq 0x21e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl 0x18(%rsp), %r8d
leaq 0x4fd5(%rip), %rsi      # 0xbcab
leaq 0x5660(%rip), %rcx      # 0xc33d
movl $0x48f, %r9d            # imm = 0x48F
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
movl $0xffffffdc, 0x34(%rsp) # imm = 0xFFFFFFDC
jmp 0x6d00
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_stats_reporting
static void *
yapio_stats_reporting(void *unused_arg)
{
    int remaining_test_contexts_to_report = 0;

    yapio_timer_t start_time;
    yapio_get_time(&start_time);

    do
    {
        pthread_mutex_lock(&yapioThreadMutex);

        remaining_test_contexts_to_report =
            yapio_stats_report_iterate(start_time);

        if (remaining_test_contexts_to_report)
            pthread_cond_wait(&yapioThreadCond, &yapioThreadMutex);

        pthread_mutex_unlock(&yapioThreadMutex);
    } while (remaining_test_contexts_to_report && !yapioHaltStonewallThread);

    log_msg(YAPIO_LL_DEBUG,
            "remaining_test_contexts_to_report=%d yapioHaltStonewallThread=%d",
            remaining_test_contexts_to_report, yapioHaltStonewallThread);

    if (remaining_test_contexts_to_report)
        yapio_stats_report_iterate(start_time);

    return unused_arg;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7220
leaq 0xe12dc6(%rip), %rdi    # 0xe19af8
callq 0x2350
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x72c0
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0x6d64
leaq 0xe13df0(%rip), %rdi    # 0xe1ab48
leaq 0xe12d99(%rip), %rsi    # 0xe19af8
callq 0x22b0
leaq 0xe12d8d(%rip), %rdi    # 0xe19af8
callq 0x2390
xorl %eax, %eax
cmpl $0x0, 0x3c(%rsp)
movb %al, 0x27(%rsp)
je 0x6d89
movb 0xe13df5(%rip), %al     # 0xe1ab78
xorb $-0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x6d2b
movl $0x3, %eax
cmpl 0x8474(%rip), %eax      # 0xf210
jg 0x6df9
movq 0x823b(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movl 0x84ca(%rip), %r8d      # 0xf290
movl 0x3c(%rsp), %r10d
movb 0xe13da7(%rip), %al     # 0xe1ab78
andb $0x1, %al
movzbl %al, %eax
leaq 0x55c9(%rip), %rsi      # 0xc3a6
leaq 0x5612(%rip), %rcx      # 0xc3f6
movl $0xaca, %r9d            # imm = 0xACA
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
cmpl $0x0, 0x3c(%rsp)
je 0x6e0f
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x72c0
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_stats_report_iterate
static int
yapio_stats_report_iterate(yapio_timer_t start_time)
{
    int remaining = 0;
    int i;
    for (i = 0; i < yapioNumTestGroups; i++)
    {
        yapio_test_group_t *ytg = &yapioTestGroups[i];
        int j;
        for (j = 0; j < ytg->ytg_num_contexts; j++)
        {
            yapio_test_ctx_t *ytc = &ytg->ytg_contexts[j];

            if (ytc->ytc_run_status == YAPIO_TEST_CTX_RUN_COMPLETE)
            {
                ytc->ytc_reported_time = start_time;
                yapio_end_timer(&ytc->ytc_reported_time);

                ytc->ytc_run_status = YAPIO_TEST_CTX_RUN_STATS_REPORTED;

                yapio_display_result(ytc, ytg);
            }

            if (ytc->ytc_run_status != YAPIO_TEST_CTX_RUN_STATS_REPORTED)
                remaining++;
        }
    }

    return remaining;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x30(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x207fd4(%rip), %eax    # 0x20f2bc
jge 0x73c8
movslq 0x20(%rsp), %rcx
leaq 0x207fd6(%rip), %rax    # 0x20f2d0
imulq $0xc088, %rcx, %rcx     # imm = 0xC088
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0xb010(%rcx), %eax
jge 0x73b6
movq 0x18(%rsp), %rax
addq $0x10, %rax
movslq 0x14(%rsp), %rcx
imulq $0xb0, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x2, 0x14(%rax)
jne 0x738e
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
callq 0x73e0
movq 0x8(%rsp), %rax
movl $0x3, 0x14(%rax)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7410
movq 0x8(%rsp), %rax
cmpl $0x3, 0x14(%rax)
je 0x73a4
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x73a6
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x7311
jmp 0x73b8
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x72de
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_get_time_duration
static void
yapio_get_time_duration(yapio_timer_t *result, const yapio_timer_t *end)
{
    result->tv_sec = end->tv_sec - result->tv_sec;
    result->tv_nsec = end->tv_nsec - result->tv_nsec;

    if (result->tv_nsec < 0)
    {
        result->tv_sec--;
        result->tv_nsec += YAPIO_NSEC_PER_SEC;
    }

    if (result->tv_nsec < 0 || result->tv_nsec >= YAPIO_NSEC_PER_SEC)
        result->tv_nsec = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rax
subq (%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rsp), %rax
subq 0x8(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jge 0x7a4c
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x3b9aca00, %rcx       # imm = 0x3B9ACA00
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jl 0x7a67
movq -0x8(%rsp), %rax
cmpq $0x3b9aca00, 0x8(%rax)  # imm = 0x3B9ACA00
jl 0x7a74
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_stonewall_thread
static void *
yapio_stonewall_thread(void *unused_arg)
{
    if (yapioUseStoneWalling)
        do
        {
            if (!yapioStoneWallNsecs--)
            {
                yapioStoneWalled = true;
                log_msg(YAPIO_LL_DEBUG, "yapioStoneWalled=%d",
                        yapioStoneWalled);
                break;
            }
            else
            {
                sleep(1);
            }
        } while (!yapioHaltStonewallThread);

    return unused_arg;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
testb $0x1, 0x7758(%rip)      # 0xf258
je 0x7ba3
jmp 0x7b08
movl 0x2077aa(%rip), %eax    # 0x20f2b8
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x20779f(%rip)    # 0x20f2b8
cmpl $0x0, %eax
jne 0x7b85
movb $0x1, 0xe13063(%rip)    # 0xe1ab88
movl $0x3, %eax
cmpl 0x76e0(%rip), %eax      # 0xf210
jg 0x7b83
movq 0x74a7(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl 0x7736(%rip), %r8d      # 0xf290
movb 0xe13028(%rip), %al     # 0xe1ab88
andb $0x1, %al
movzbl %al, %eax
leaq 0x4a16(%rip), %rsi      # 0xc582
leaq 0x4a32(%rip), %rcx      # 0xc5a5
movl $0xb1e, %r9d            # imm = 0xB1E
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2370
jmp 0x7ba1
movl $0x1, %edi
callq 0x2190
jmp 0x7b91
movb 0xe12fe1(%rip), %al     # 0xe1ab78
xorb $-0x1, %al
testb $0x1, %al
jne 0x7b08
jmp 0x7ba3
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_test_context_setup
static int
yapio_test_context_setup(yapio_test_ctx_t *ytc, const int test_num)
{
    ytc->ytc_test_num = test_num;
    ytc->ytc_run_status = YAPIO_TEST_CTX_RUN_NOT_STARTED;

    int rc = ytc->ytc_remote_locality ?
        yapio_test_context_setup_distributed(ytc) :
        yapio_test_context_setup_local(ytc);

    if (rc)
    {
        log_msg(YAPIO_LL_ERROR,
                "yapio_test_context_setup_%s: %s",
                ytc->ytc_remote_locality ? "distributed" : "local",
                strerror(-rc));

        yapio_test_ctx_release(ytc);

        return rc;
    }

    return yapio_prepare_fpp_file_desc(ytc);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movl 0x44(%rsp), %ecx
movq 0x48(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x48(%rsp), %rax
movl $0x0, 0x14(%rax)
movq 0x48(%rsp), %rax
movb (%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x7bf9
movq 0x48(%rsp), %rdi
callq 0x86d0
movl %eax, 0x3c(%rsp)
jmp 0x7c07
movq 0x48(%rsp), %rdi
callq 0x87c0
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x40(%rsp)
cmpl $0x0, 0x40(%rsp)
je 0x7cd3
movl $0x1, %eax
cmpl 0x75eb(%rip), %eax      # 0xf210
jg 0x7cbf
movq 0x73ae(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x1, %edi
callq 0x4890
movq %rax, 0x20(%rsp)
movl 0x7641(%rip), %eax      # 0xf290
movl %eax, 0x2c(%rsp)
movq 0x48(%rsp), %rax
movb (%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %edx
leaq 0x4df2(%rip), %rax      # 0xca5b
leaq 0x4a57(%rip), %rcx      # 0xc6c7
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, 0x30(%rsp)
xorl %edi, %edi
subl 0x40(%rsp), %edi
callq 0x21e0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl 0x2c(%rsp), %r8d
movq 0x30(%rsp), %r10
leaq 0x499f(%rip), %rsi      # 0xc641
leaq 0x49c7(%rip), %rcx      # 0xc670
movl $0x8d2, %r9d            # imm = 0x8D2
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
movq 0x48(%rsp), %rdi
callq 0x8680
movl 0x40(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x7ce1
movq 0x48(%rsp), %rdi
callq 0x8970
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_send_test_results
static void
yapio_send_test_results(yapio_test_ctx_t *ytc)
{
    if (yapio_leader_rank())
    {
        if (ytc->ytc_group->ytg_group_num > 0)
        {
            MPI_OP_START;
            int rc = MPI_Send(ytc, sizeof(yapio_test_ctx_t), MPI_BYTE, 0,
                              ytc->ytc_test_num, MPI_COMM_WORLD);
            MPI_OP_END;

            if (rc != MPI_SUCCESS)
                log_msg(YAPIO_LL_FATAL, "MPI_Send failed: %d", rc);
        }
        else
        {
            /* Local operation to wake up stats reporting thread.
             */
            yapio_stat_ready();
        }
    }

    MPI_OP_START;
    MPI_Bcast(&ytc->ytc_stonewalled, sizeof(bool), MPI_CHAR, 0,
              ytc->ytc_group->ytg_comm);
    MPI_OP_END;

    log_msg_r0(YAPIO_LL_DEBUG, "ytc_test_num=%d stonewalled=%d",
               ytc->ytc_test_num, ytc->ytc_stonewalled);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
callq 0x5910
testb $0x1, %al
jne 0x83e7
jmp 0x84b1
movq 0x30(%rsp), %rax
movq 0xa0(%rax), %rax
cmpl $0x0, 0xb014(%rax)
jle 0x84aa
leaq 0xe116f1(%rip), %rdi    # 0xe19af8
callq 0x2350
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x10(%rax), %r8d
movl $0xb0, %esi
movq 0x6bca(%rip), %rdx      # 0xeff0
xorl %ecx, %ecx
movq 0x6ba1(%rip), %r9       # 0xefd0
callq 0x2050
movl %eax, 0x2c(%rsp)
leaq 0xe116b9(%rip), %rdi    # 0xe19af8
callq 0x2390
cmpl $0x0, 0x2c(%rsp)
je 0x84a8
xorl %eax, %eax
cmpl 0x6dbd(%rip), %eax      # 0xf210
jg 0x84a6
movq 0x6b84(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
xorl %edi, %edi
callq 0x4890
movq 0x20(%rsp), %rdi
movq %rax, %rdx
movl 0x6e16(%rip), %r8d      # 0xf290
movl 0x2c(%rsp), %eax
leaq 0x4852(%rip), %rsi      # 0xccd7
leaq 0x486e(%rip), %rcx      # 0xccfa
movl $0x9b2, %r9d            # imm = 0x9B2
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2370
movl $0x1, %edi
callq 0x40f0
jmp 0x84a8
jmp 0x84af
callq 0x7ac0
jmp 0x84b1
leaq 0xe11640(%rip), %rdi    # 0xe19af8
callq 0x2350
movq 0x30(%rsp), %rdi
addq $0x1, %rdi
movq 0x30(%rsp), %rax
movq 0xa0(%rax), %rax
movq (%rax), %r8
movl $0x1, %esi
movq 0x6aaf(%rip), %rdx      # 0xef90
xorl %ecx, %ecx
callq 0x2270
leaq 0xe11609(%rip), %rdi    # 0xe19af8
callq 0x2390
callq 0x5910
testb $0x1, %al
jne 0x84ff
jmp 0x856f
movl $0x3, %eax
cmpl 0x6d06(%rip), %eax      # 0xf210
jg 0x856d
movq 0x6acd(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movl 0x6d5c(%rip), %r8d      # 0xf290
movq 0x30(%rsp), %rax
movl 0x10(%rax), %r10d
movq 0x30(%rsp), %rax
movb 0x1(%rax), %al
andb $0x1, %al
movzbl %al, %eax
leaq 0x47c1(%rip), %rsi      # 0xcd12
leaq 0x47a2(%rip), %rcx      # 0xccfa
movl $0x9c2, %r9d            # imm = 0x9C2
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
jmp 0x856f
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_try_sync_md
static void
yapio_try_sync_md(const yapio_test_ctx_t *ytc, const bool last_writer_ctx)
{
    if (!ytc->ytc_read && ytc->ytc_group->ytg_keep_file)
    {
        if (ytc->ytc_stonewalled)
        {
            /* User has requested to keep the output data set but the
             * current write has been stonewalled.
             */
            ytc->ytc_group->ytg_keep_file = 0;
            log_msg(YAPIO_LL_WARN,
                    "Data set %s%s was stonewalled and will be removed.",
                    ytc->ytc_group->ytg_prefix, ytc->ytc_group->ytg_suffix);
        }
        else if (last_writer_ctx)
        {
            yapio_store_md_final_state();
        }
    }
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movb (%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8675
movq 0x20(%rsp), %rax
movq 0xa0(%rax), %rax
testb $0x1, 0xb031(%rax)
je 0x8675
movq 0x20(%rsp), %rax
testb $0x1, 0x1(%rax)
je 0x8665
movq 0x20(%rsp), %rax
movq 0xa0(%rax), %rax
movb $0x0, 0xb031(%rax)
movl $0x2, %eax
cmpl 0x6c20(%rip), %eax      # 0xf210
jg 0x8663
movq 0x69e7(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x2, %edi
callq 0x4890
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl 0x6c76(%rip), %r8d      # 0xf290
movq 0x20(%rsp), %rax
movq 0xa0(%rax), %r10
addq $0xb03f, %r10           # imm = 0xB03F
movq 0x20(%rsp), %rax
movq 0xa0(%rax), %rax
addq $0xb038, %rax           # imm = 0xB038
leaq 0x46fa(%rip), %rsi      # 0xcd40
leaq 0x4735(%rip), %rcx      # 0xcd82
movl $0xa20, %r9d            # imm = 0xA20
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
jmp 0x8673
testb $0x1, 0x1f(%rsp)
je 0x8671
callq 0xacd0
jmp 0x8673
jmp 0x8675
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_test_context_setup_distributed
static int
yapio_test_context_setup_distributed(yapio_test_ctx_t *ytc)
{
    enum yapio_patterns pattern = ytc->ytc_io_pattern;

    if (!ytc->ytc_remote_locality)
    {
        return -EINVAL;
    }
    else if (pattern != YAPIO_IOP_SEQUENTIAL &&
             pattern != YAPIO_IOP_RANDOM &&
             pattern != YAPIO_IOP_STRIDED)
    {
        log_msg(YAPIO_LL_WARN, "unknown io_pattern=%d", pattern);
        return -EBADRQC;
    }

    return pattern == YAPIO_IOP_SEQUENTIAL ?
        yapio_test_context_setup_distributed_sequential(ytc) :
        yapio_test_context_setup_distributed_random_or_strided(ytc);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
movb (%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8706
movl $0xffffffea, 0x34(%rsp) # imm = 0xFFFFFFEA
jmp 0x87ab
cmpl $0x0, 0x24(%rsp)
je 0x877c
cmpl $0x1, 0x24(%rsp)
je 0x877c
cmpl $0x2, 0x24(%rsp)
je 0x877c
movl $0x2, %eax
cmpl 0x6aea(%rip), %eax      # 0xf210
jg 0x8772
movq 0x68b1(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x2, %edi
callq 0x4890
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movl 0x6b40(%rip), %r8d      # 0xf290
movl 0x24(%rsp), %eax
leaq 0x3f2e(%rip), %rsi      # 0xc689
leaq 0x3f4c(%rip), %rcx      # 0xc6ae
movl $0x899, %r9d            # imm = 0x899
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2370
movl $0xffffffc8, 0x34(%rsp) # imm = 0xFFFFFFC8
jmp 0x87ab
jmp 0x877e
cmpl $0x0, 0x24(%rsp)
jne 0x8795
movq 0x28(%rsp), %rdi
callq 0x8a20
movl %eax, 0x14(%rsp)
jmp 0x87a3
movq 0x28(%rsp), %rdi
callq 0x8c70
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_prepare_fpp_file_desc
static int
yapio_prepare_fpp_file_desc(const yapio_test_ctx_t *ytc)
{
    int rc = 0;

    if (ytc->ytc_group->ytg_file_per_process)
    {
        int num_ops = 0;

        const yapio_blk_md_t *md_in =
            yapio_test_ctx_to_md_array(ytc, YAPIO_TEST_CTX_MDH_IN, &num_ops);

        int i = 0;
        for (i = 0; i < num_ops; i++)
        {
            rc = yapio_open_fpp_file(md_in[i].ybm_owner_rank_fpp, O_RDWR);
            if (rc)
                break;
        }
    }

   return rc;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq 0xa0(%rax), %rax
testb $0x1, 0xb030(%rax)
je 0x8a0a
movl $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
xorl %esi, %esi
leaq 0x18(%rsp), %rdx
callq 0x24f0
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x8a08
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edi
movl $0x2, %esi
callq 0x6960
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x89f9
jmp 0x8a08
jmp 0x89fb
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x89c4
jmp 0x8a0a
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_test_context_alloc
static yapio_blk_md_t *
yapio_test_context_alloc(yapio_test_ctx_t *ytc,
                         enum yapio_test_ctx_mdh_in_out in_out, size_t nblks)
{
    if (in_out >= YAPIO_TEST_CTX_MDH_MAX)
    {
        errno = EINVAL;
        return NULL;
    }

    yapio_test_ctx_md_t *ytcmh = &ytc->ytc_in_out_md_ops[in_out];

    ytcmh->ytcmh_num_ops = nblks;
    ytcmh->ytcmh_ops = YAPIO_CALLOC(nblks, sizeof(yapio_blk_md_t));

    return ytcmh->ytcmh_ops;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
cmpl $0x2, 0x44(%rsp)
jb 0x9462
callq 0x2230
movl $0x16, (%rax)
movq $0x0, 0x50(%rsp)
jmp 0x9529
movq 0x48(%rsp), %rax
addq $0x68, %rax
movl 0x44(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x38(%rsp), %rdi
movl $0x10, %esi
callq 0x22c0
movq %rax, 0x28(%rsp)
movl $0x3, %eax
cmpl 0x5d67(%rip), %eax      # 0xf210
jg 0x9505
movq 0x5b2e(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movl 0x5dbd(%rip), %r8d      # 0xf290
movq 0x28(%rsp), %r10
movq 0x38(%rsp), %rax
shlq $0x4, %rax
leaq 0x2967(%rip), %rsi      # 0xbe4f
leaq 0x325d(%rip), %rcx      # 0xc74c
movl $0x752, %r9d            # imm = 0x752
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: skip_io_or_not
static bool
skip_io_or_not(int ops_left, int skips_left)
{
    /* for random number generation */
    srand(time(NULL));

    /* skip randomly or skip all remaining IOs
     * because there's no room for choosing */
    if (skips_left &&
        (skips_left == ops_left || rand() % (ops_left / skips_left)))
        return true;
    else
        return false;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x23e0
movl %eax, %edi
callq 0x22a0
cmpl $0x0, 0xc(%rsp)
je 0x98c4
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
je 0x98bd
callq 0x2360
movl %eax, 0x8(%rsp)
movl 0x10(%rsp), %eax
cltd
idivl 0xc(%rsp)
movl %eax, %ecx
movl 0x8(%rsp), %eax
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x98c4
movb $0x1, 0x17(%rsp)
jmp 0x98c9
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_source_md_update_writer_rank
static void
yapio_source_md_update_writer_rank(size_t source_md_idx, int new_writer_rank)
{
    if (source_md_idx >= yapioMyTestGroup->ytg_num_blks_per_rank)
        log_msg(YAPIO_LL_FATAL, "out of bounds source_md_idx=%zu",
                source_md_idx);

    log_msg(YAPIO_LL_TRACE, "%d %zu", new_writer_rank, source_md_idx);

    yapioSourceBlkMd[source_md_idx].ybm_writer_rank = new_writer_rank;
    yapioSourceBlkMd[source_md_idx].ybm_not_hole = 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq 0x5957(%rip), %rcx      # 0xf250
cmpq 0xb020(%rcx), %rax
jb 0x9961
xorl %eax, %eax
cmpl 0x5906(%rip), %eax      # 0xf210
jg 0x995f
movq 0x56cd(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
xorl %edi, %edi
callq 0x4890
movq 0x20(%rsp), %rdi
movq %rax, %rdx
movl 0x595f(%rip), %r8d      # 0xf290
movq 0x30(%rsp), %rax
leaq 0x2efb(%rip), %rsi      # 0xc838
leaq 0x2f23(%rip), %rcx      # 0xc867
movl $0x60f, %r9d            # imm = 0x60F
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
movl $0x1, %edi
callq 0x40f0
jmp 0x9961
movl $0x4, %eax
cmpl 0x58a4(%rip), %eax      # 0xf210
jg 0x99c4
movq 0x566b(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x4, %edi
callq 0x4890
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movl 0x58fa(%rip), %r8d      # 0xf290
movl 0x2c(%rsp), %r10d
movq 0x30(%rsp), %rax
leaq 0x2ee3(%rip), %rsi      # 0xc88a
leaq 0x2eb9(%rip), %rcx      # 0xc867
movl $0x611, %r9d            # imm = 0x611
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
movl 0x2c(%rsp), %ecx
movq 0x5891(%rip), %rax      # 0xf260
movq 0x30(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq 0x587c(%rip), %rax      # 0xf260
movq 0x30(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movabsq $-0x4000000000000001, %rcx # imm = 0xBFFFFFFFFFFFFFFF
andq 0x8(%rax), %rcx
movabsq $0x4000000000000000, %rdx # imm = 0x4000000000000000
orq %rdx, %rcx
movq %rcx, 0x8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: select_holes
static void
select_holes(int num_ops, int skips_left, yapio_blk_md_t *md)
{
    int i;
    for (i = 0; i < num_ops; i++)
    {
        if (skip_io_or_not(num_ops - i, skips_left))
        {
            log_msg(YAPIO_LL_DEBUG, "skip IO # %d\n", i);
            md[i].ybm_skip_io = 1;
            skips_left--;
        }
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x9f25
movl 0x24(%rsp), %edi
subl 0x14(%rsp), %edi
movl 0x20(%rsp), %esi
callq 0x9870
testb $0x1, %al
jne 0x9e81
jmp 0x9f13
movl $0x3, %eax
cmpl 0x5384(%rip), %eax      # 0xf210
jg 0x9ed8
movq 0x514b(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x3, %edi
callq 0x4890
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl 0x53da(%rip), %r8d      # 0xf290
movl 0x14(%rsp), %eax
leaq 0x2925(%rip), %rsi      # 0xc7e6
leaq 0x2b6d(%rip), %rcx      # 0xca35
movl $0x593, %r9d            # imm = 0x593
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2370
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq 0x8(%rax), %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
orq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl 0x20(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x9f15
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x9e59
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_read_from_dev_urandom
static int
yapio_read_from_dev_urandom(void *buffer, size_t size)
{
    int fd = open("/dev/urandom", O_RDONLY);
    if (fd < 0)
    {
        fd = -errno;
        log_msg(YAPIO_LL_ERROR, "open: %s", strerror(errno));
        return fd;
    }

    int error = 0;
    size_t nbytes = 0;
    do
    {
        ssize_t rc = read(fd, ((char *)buffer) + nbytes, size - nbytes);
        if (rc < 0)
        {
            error = -errno;
            log_msg(YAPIO_LL_ERROR, "read: %s", strerror(errno));
            break;
        }

        nbytes += rc;

    } while (nbytes < size);

    close(fd);
    return error;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
leaq 0x2a97(%rip), %rdi      # 0xc9dc
xorl %esi, %esi
movb $0x0, %al
callq 0x23b0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jge 0x9fe9
callq 0x2230
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, 0x4c(%rsp)
movl $0x1, %eax
cmpl 0x5298(%rip), %eax      # 0xf210
jg 0x9fdc
movq 0x505f(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x1, %edi
callq 0x4890
movq %rax, 0x28(%rsp)
movl 0x52f2(%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 0x2a25(%rip), %rsi      # 0xc9e9
leaq 0x2a36(%rip), %rcx      # 0xca01
movl $0x72d, %r9d            # imm = 0x72D
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
movl 0x4c(%rsp), %eax
movl %eax, 0x64(%rsp)
jmp 0xa0d9
movl $0x0, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movl 0x4c(%rsp), %edi
movq 0x58(%rsp), %rsi
addq 0x40(%rsp), %rsi
movq 0x50(%rsp), %rdx
subq 0x40(%rsp), %rdx
callq 0x20f0
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jge 0xa0a9
callq 0x2230
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, 0x48(%rsp)
movl $0x1, %eax
cmpl 0x51cd(%rip), %eax      # 0xf210
jg 0xa0a7
movq 0x4f94(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %edi
callq 0x4890
movq %rax, 0x10(%rsp)
movl 0x5227(%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 0x298e(%rip), %rsi      # 0xca1d
leaq 0x296b(%rip), %rcx      # 0xca01
movl $0x739, %r9d            # imm = 0x739
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
jmp 0xa0c8
movq 0x38(%rsp), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x50(%rsp), %rax
jb 0x9ffa
movl 0x4c(%rsp), %edi
callq 0x2080
movl 0x48(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_apply_contents_to_io_buffer
static void
yapio_apply_contents_to_io_buffer(char *buf, size_t buf_len,
                                  const yapio_blk_md_t *md)
{
    unsigned long long *buffer_of_longs = (unsigned long long *)buf;
    size_t num_words = buf_len / sizeof(unsigned long long);

    size_t i;
    for (i = 0; i < num_words; i++)
    {
        buffer_of_longs[i] = yapio_get_content_word(md, i);

        log_msg(YAPIO_LL_TRACE, "%zu:%llx", i, buffer_of_longs[i]);
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
shrq $0x3, %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0xa1d5
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xa620
movq %rax, %rdx
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x4, %eax
cmpl 0x50b1(%rip), %eax      # 0xf210
jg 0xa1c0
movq 0x4e78(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x4, %edi
callq 0x4890
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl 0x5107(%rip), %r8d      # 0xf290
movq 0x18(%rsp), %r10
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0x29bd(%rip), %rsi      # 0xcb60
leaq 0x29ce(%rip), %rcx      # 0xcb78
movl $0x62d, %r9d            # imm = 0x62D
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2370
jmp 0xa1c2
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xa124
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_fsync
static int
yapio_fsync(void)
{
    int rc = 0;

    if (yapioMyTestGroup->ytg_file_per_process)
    {
        int i;
        for (i = 0; i < yapioNumRanks; i++)
        {
            if (yapioFileDescFpp[i] < 0)
                continue;

            if (YAPIO_SYS_CALL(fsync)(yapioFileDescFpp[i]))
            {
                rc = errno;
                break;
            }
        }
    }
    else
    {
        if (YAPIO_SYS_CALL(fsync)(yapioFileDesc))
            rc = errno;
    }

    if (rc)
    {
        log_msg(YAPIO_LL_ERROR, "fsync(): %s", strerror(rc));
        rc = -errno;
    }

    return rc;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movq 0x4d5d(%rip), %rax      # 0xf250
testb $0x1, 0xb030(%rax)
je 0xa563
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x204d92(%rip), %eax    # 0x20f2a0
jge 0xa561
movq 0xe0f609(%rip), %rax    # 0xe19b20
movslq 0x20(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0xa524
jmp 0xa554
movq 0x4cdd(%rip), %rax      # 0xf208
movq 0x10(%rax), %rax
movq 0xe0f5ea(%rip), %rcx    # 0xe19b20
movslq 0x20(%rsp), %rdx
movl (%rcx,%rdx,4), %edi
callq *%rax
cmpl $0x0, %eax
je 0xa552
callq 0x2230
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0xa561
jmp 0xa554
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xa504
jmp 0xa588
movq 0x4c9e(%rip), %rax      # 0xf208
movq 0x10(%rax), %rax
movl 0xe0f580(%rip), %edi    # 0xe19af4
callq *%rax
cmpl $0x0, %eax
je 0xa586
callq 0x2230
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0xa588
cmpl $0x0, 0x24(%rsp)
je 0xa60b
movl $0x1, %eax
cmpl 0x4c76(%rip), %eax      # 0xf210
jg 0xa5fb
movq 0x4a3d(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %edi
callq 0x4890
movq %rax, 0x10(%rsp)
movl 0x4cd0(%rip), %eax      # 0xf290
movl %eax, 0x1c(%rsp)
movl 0x24(%rsp), %edi
callq 0x21e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl 0x1c(%rsp), %r8d
leaq 0x2562(%rip), %rsi      # 0xcb45
leaq 0x264d(%rip), %rcx      # 0xcc37
movl $0x683, %r9d            # imm = 0x683
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2370
callq 0x2230
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_get_content_word
static unsigned long long
yapio_get_content_word(const yapio_blk_md_t *md, size_t word_num)
{
    unsigned long long content_word =
        (yapio_get_blk_magic(md->ybm_blk_number) + md->ybm_writer_rank +
         md->ybm_blk_number + md->ybm_owner_rank_fpp + word_num);

    return content_word;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movabsq $0x3fffffffffffffff, %rdi # imm = 0x3FFFFFFFFFFFFFFF
andq 0x8(%rax), %rdi
callq 0xa690
movq 0x10(%rsp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rdx
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
andq 0x8(%rdx), %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movslq 0x4(%rcx), %rcx
addq %rcx, %rax
addq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/00pauln00[P]yapio/yapio.c
// Function: yapio_gather_barrier_stats_median_cmp
static int
yapio_gather_barrier_stats_median_cmp(const void *a, const void *b)
{
    const yapio_per_rank_result_t *yppr_a = a;
    const yapio_per_rank_result_t *yppr_b = b;

    float a_val = yapio_timer_to_float(&yppr_a->yprr_barrier_wait);
    float b_val = yapio_timer_to_float(&yppr_b->yprr_barrier_wait);

    if (a_val > b_val)
        return 1;
    else if (a_val < b_val)
        return -1;

    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a80
movss %xmm0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a80
movss %xmm0, 0x8(%rsp)
movss 0xc(%rsp), %xmm0
ucomiss 0x8(%rsp), %xmm0
jbe 0xaca1
movl $0x1, 0x34(%rsp)
jmp 0xacc6
movss 0xc(%rsp), %xmm1
movss 0x8(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xacbc
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xacc6
jmp 0xacbe
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/valgrind/potential-memleaks.c
// Function: pl_freebsd_getdelim
static void
pl_freebsd_getdelim(void)
{
	size_t linecap = 0;
	char * line = NULL;

	if (getline(&line, &linecap, stdin) == -1)
		printf("error in getline()\n");

	/* Clean up. */
	free(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq 0x2c31(%rip), %rax      # 0x3fd0
movq (%rax), %rdx
leaq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x10e0
cmpq $-0x1, %rax
jne 0x13c3
leaq 0xd8b(%rip), %rdi       # 0x2147
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/valgrind/potential-memleaks.c
// Function: pl_workthread_strerror_localtime
static void *
pl_workthread_strerror_localtime(void * cookie)
{
	char * str = strerror(1);
	time_t now;
	struct tm tm;

	(void)cookie; /* UNUSED */
	(void)str; /* UNUSED */

	if (time(&now) == (time_t)(-1))
		fprintf(stderr, "time");
	localtime_r(&now, &tm);

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
callq 0x1120
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x10c0
cmpq $-0x1, %rax
jne 0x1651
movq 0x29b8(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xa80(%rip), %rsi       # 0x20ca
movb $0x0, %al
callq 0x10a0
leaq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1040
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/pair_sum/pair_sum_test.c
// Function: test_pair_sum
void test_pair_sum(void) {
	Vector numbers = vector_create(0, free);
	for (int i = 0; i < 10; i++)
		vector_insert_last(numbers, create_int(i));

	int a, b;
	TEST_ASSERT(!pair_sum(90, numbers, &a, &b));
	TEST_ASSERT( pair_sum(15, numbers, &a, &b));
	TEST_ASSERT(a + b == 15);

	vector_destroy(numbers);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %edi, %edi
movq 0x6bdf(%rip), %rsi      # 0xafc0
callq 0x5100
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x441e
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x43a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x52a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x43f1
jmp 0x4420
movq -0x8(%rbp), %rsi
movl $0x5a, %edi
leaq -0x10(%rbp), %rdx
leaq -0x14(%rbp), %rcx
callq 0x5030
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2e9d(%rip), %rsi      # 0x72e1
movl $0x13, %edx
leaq 0x2f64(%rip), %rcx      # 0x73b4
leaq 0x2e9a(%rip), %r8       # 0x72f1
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4468
callq 0x2e50
jmp 0x446a
jmp 0x446c
movq -0x8(%rbp), %rsi
movl $0xf, %edi
leaq -0x10(%rbp), %rdx
leaq -0x14(%rbp), %rcx
callq 0x5030
andb $0x1, %al
movzbl %al, %edi
leaq 0x2e53(%rip), %rsi      # 0x72e1
movl $0x14, %edx
leaq 0x2f1a(%rip), %rcx      # 0x73b4
leaq 0x2e6f(%rip), %r8       # 0x7310
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x44b2
callq 0x2e50
jmp 0x44b4
jmp 0x44b6
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
cmpl $0xf, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2e13(%rip), %rsi      # 0x72e1
movl $0x15, %edx
leaq 0x2eda(%rip), %rcx      # 0x73b4
leaq 0x2e4d(%rip), %r8       # 0x732e
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x44f2
callq 0x2e50
jmp 0x44f4
movq -0x8(%rbp), %rdi
callq 0x54b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/pair_sum/pair_sum.c
// Function: pair_sum
bool pair_sum(int target, Vector numbers, int* res_a, int* res_b) {
	// Στο map θα αποθηκεύουμε τα στοιχεία του vector. Δεν κάνουμε malloc
	// οπότε δε θέλουμε και free, εμείς αποθηκεύουμε στοιχεία που έχουν δημιουργηθεί αλλού!
	Map seen = map_create((CompareFunc)compare_ints, NULL, NULL);
	bool result = false;

	int size = vector_size(numbers);
	for (int i = 0; i < size; i++) {
		int* a = vector_get_at(numbers, i);
		int b = target - *a;

		if (map_find(seen, &b) != NULL) {
			*res_a = *a;
			*res_b = b;
			result = true;
			break;
		}

		map_insert(seen, a, a);		// Για value θέλουμε μια οποιαδήποτε μη-NULL τιμή, οπότε το θέτουμε και αυτό ίσο με a
	}

	map_destroy(seen);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x3e(%rip), %rdi       # 0x5010
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x56d0
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5180
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x50e3
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x51a0
movq %rax, -0x40(%rbp)
movl -0x4(%rbp), %eax
movq -0x40(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x5840
cmpq $0x0, %rax
je 0x50c7
movq -0x40(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x44(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x29(%rbp)
jmp 0x50e3
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x58b0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5075
movq -0x28(%rbp), %rdi
callq 0x5a80
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/pair_sum/../../modules/UsingADTSet/ADTMap.c
// Function: map_create
Map map_create(CompareFunc compare, DestroyFunc destroy_key, DestroyFunc destroy_value) {
	assert(compare != NULL);	// LCOV_EXCL_LINE

	Map map = malloc(sizeof(*map));
	map->set = set_create((CompareFunc)compare_map_nodes, (DestroyFunc)destroy_map_node);
	map->compare = compare;
	map->destroy_key = destroy_key;
	map->destroy_value = destroy_value;
	return map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x56ed
jmp 0x570c
leaq 0x2727(%rip), %rdi      # 0x7e1b
leaq 0x2730(%rip), %rsi      # 0x7e2b
movl $0x2b, %edx
leaq 0x2747(%rip), %rcx      # 0x7e4e
callq 0x20f0
movl $0x20, %edi
callq 0x2180
movq %rax, -0x20(%rbp)
leaq 0x4f(%rip), %rdi        # 0x5770
leaq 0x88(%rip), %rsi        # 0x57b0
callq 0x5c30
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)