LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirinternal.c
// Function: sir_makeinit
bool _sir_makeinit(sirinit* si) {
    bool retval = _sir_validptr(si);

    if (retval) {
        (void)memset(si, 0, sizeof(sirinit));

        si->d_stdout.opts   = SIRO_DEFAULT;
        si->d_stdout.levels = SIRL_DEFAULT;

        si->d_stderr.opts   = SIRO_DEFAULT;
        si->d_stderr.levels = SIRL_DEFAULT;

#if !defined(SIR_NO_SYSTEM_LOGGERS)
        si->d_syslog.opts   = SIRO_DEFAULT;
        si->d_syslog.levels = SIRL_DEFAULT;
#else
        si->d_syslog.opts   = SIRO_MSGONLY;
        si->d_syslog.levels = SIRL_NONE;
#endif
    }

    return retval;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5ce3
movl $0x108, %edx            # imm = 0x108
movq %rbx, %rdi
xorl %esi, %esi
callq 0x21b0
movl $0x100000, %eax         # imm = 0x100000
movl %eax, 0x4(%rbx)
movw $0x100, %cx             # imm = 0x100
movw %cx, (%rbx)
movl %eax, 0xc(%rbx)
movw %cx, 0x8(%rbx)
movl %eax, 0x14(%rbx)
movw %cx, 0x10(%rbx)
jmp 0x5d00
leaq 0x3ebe(%rip), %rsi      # 0x9ba8
leaq 0x3ec5(%rip), %rdx      # 0x9bb6
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x5b, %ecx
callq 0x31c0
testq %rbx, %rbx
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirinternal.c
// Function: sir_reset_tls
void _sir_reset_tls(void) {
    _sir_resetstr(_sir_tid);
    (void)memset(&_sir_last_thrd_chk, 0, sizeof(sir_time));
    _sir_last_timestamp = 0;
    _sir_reset_tls_error();
}

// Assembly:
pushq %rax
movq %fs:0x0, %rax
movb $0x0, -0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movq $0x0, -0x10(%rax)
popq %rax
jmp 0x36f0
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirinternal.c
// Function: sir_cleanup
bool _sir_isinitialized(void) {
#if defined(__HAVE_ATOMIC_H__)
    if (_SIR_MAGIC == atomic_load(&_sir_magic))
        return true;
#else
    if (_SIR_MAGIC == _sir_magic)
        return true;
#endif
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x823f(%rip), %rax      # 0xe4e0
cmpq $0x60906090, %rax       # imm = 0x60906090
je 0x62ce
leaq 0x392e(%rip), %rsi      # 0x9bde
leaq 0x38ff(%rip), %rdx      # 0x9bb6
movl $0x80020000, %edi       # imm = 0x80020000
movl $0x11a, %ecx            # imm = 0x11A
callq 0x31c0
testb %al, %al
je 0x6423
leaq 0x84cb(%rip), %rdi      # 0xe7a0
callq 0x799c
testb %al, %al
je 0x63d2
leaq 0x84df(%rip), %rdi      # 0xe7c8
callq 0x4ae3
movl %eax, %ebx
leaq 0x84a9(%rip), %rdi      # 0xe7a0
callq 0x7a3a
leaq 0x854d(%rip), %rdi      # 0xe850
callq 0x799c
testb %al, %al
je 0x63ec
leaq 0x8561(%rip), %rdi      # 0xe878
callq 0x82b0
movl %eax, %r15d
leaq 0x852a(%rip), %rdi      # 0xe850
callq 0x7a3a
leaq 0x81b6(%rip), %rdi      # 0xe4e8
callq 0x799c
leaq 0x81d2(%rip), %rcx      # 0xe510
xorl %r14d, %r14d
testb %al, %al
cmovneq %rcx, %r14
je 0x6406
testb $0x1, 0x81d4(%rip)      # 0xe528
je 0x6362
callq 0x2070
andb $-0x2, 0x81c6(%rip)     # 0xe528
movl $0x0, 0x81bc(%rip)      # 0xe528
xorl %r12d, %r12d
movq %r12, 0x81ba(%rip)      # 0xe530
callq 0x88db
movl %eax, %ebp
andb %r15b, %bpl
andb %bl, %bpl
xorl %eax, %eax
xchgq %rax, 0x8154(%rip)      # 0xe4e0
movq %fs:0x0, %rax
movb $0x0, -0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movq %r12, -0x10(%rax)
callq 0x36f0
movl $0x290, %edx            # imm = 0x290
movq %r14, %rdi
xorl %esi, %esi
callq 0x21b0
leaq 0x811d(%rip), %rdi      # 0xe4e8
callq 0x7a3a
jmp 0x6425
leaq 0x37f8(%rip), %rsi      # 0x9bd1
leaq 0x37d6(%rip), %rdx      # 0x9bb6
movl $0x800f0000, %edi       # imm = 0x800F0000
movl $0xd9, %ecx
jmp 0x641e
leaq 0x37de(%rip), %rsi      # 0x9bd1
leaq 0x37bc(%rip), %rdx      # 0x9bb6
movl $0x800f0000, %edi       # imm = 0x800F0000
movl $0xe2, %ecx
jmp 0x641e
leaq 0x37c4(%rip), %rsi      # 0x9bd1
leaq 0x37a2(%rip), %rdx      # 0x9bb6
movl $0x800f0000, %edi       # imm = 0x800F0000
movl $0xe9, %ecx
callq 0x31c0
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirinternal.c
// Function: sir_updatelevels
static
bool _sir_updatelevels(const char* name, sir_levels* old, const sir_levels* new) {
    bool retval = _sir_validstr(name) && _sir_validptr(old) && _sir_validptr(new);
    if (retval) {
        if (*old != *new) {
            _sir_selflog("updating %s levels from %04"PRIx16" to %04"PRIx16, name, *old, *new);
            *old = *new;
        } else {
            _sir_selflog("skipped superfluous update of %s levels: %04"PRIx16, name, *old);
        }
    }
    return retval;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rax
movl $0x800a0000, %edi       # imm = 0x800A0000
testq %rax, %rax
je 0x64f3
cmpb $0x0, (%rax)
je 0x64f3
movl $0x800b0000, %edi       # imm = 0x800B0000
testq %rbx, %rbx
je 0x64f3
testq %r14, %r14
setne %bpl
jne 0x650d
jmp 0x64f5
xorl %ebp, %ebp
leaq 0x387a(%rip), %rsi      # 0x9d76
leaq 0x36b3(%rip), %rdx      # 0x9bb6
movl $0x145, %ecx            # imm = 0x145
callq 0x31c0
testb %bpl, %bpl
je 0x651e
movzwl (%r14), %eax
cmpw %ax, (%rbx)
je 0x651e
movw %ax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirinternal.c
// Function: sir_updateopts
static
bool _sir_updateopts(const char* name, sir_options* old, const sir_options* new) {
    bool retval = _sir_validstr(name) && _sir_validptr(old) && _sir_validptr(new);
    if (retval) {
        if (*old != *new) {
            _sir_selflog("updating %s options from %08"PRIx32" to %08"PRIx32, name, *old, *new);
            *old = *new;
        } else {
            _sir_selflog("skipped superfluous update of %s options: %08"PRIx32, name, *old);
        }
    }
    return retval;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rax
movl $0x800a0000, %edi       # imm = 0x800A0000
testq %rax, %rax
je 0x656a
cmpb $0x0, (%rax)
je 0x656a
movl $0x800b0000, %edi       # imm = 0x800B0000
testq %rbx, %rbx
je 0x656a
testq %r14, %r14
setne %bpl
jne 0x6584
jmp 0x656c
xorl %ebp, %ebp
leaq 0x3815(%rip), %rsi      # 0x9d88
leaq 0x363c(%rip), %rdx      # 0x9bb6
movl $0x153, %ecx            # imm = 0x153
callq 0x31c0
testb %bpl, %bpl
je 0x6592
movl (%r14), %eax
cmpl %eax, (%rbx)
je 0x6592
movl %eax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirinternal.c
// Function: sir_sysloglevels
bool _sir_sysloglevels(sirinit* si, const sir_update_config_data* data) {
    bool updated = _sir_updatelevels(SIR_DESTNAME_SYSLOG, &si->d_syslog.levels, data->levels);
    if (updated) {
        _sir_setbitshigh(&si->d_syslog._state.mask, SIRSL_UPDATED | SIRSL_LEVELS);
        updated = _sir_syslog_updated(si, data);
        _sir_setbitslow(&si->d_syslog._state.mask, SIRSL_UPDATED | SIRSL_LEVELS);
    }
    return updated;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rsi
movq 0x8(%r14), %rdx
leaq 0x3629(%rip), %rdi      # 0x9c09
callq 0x64c2
testb %al, %al
je 0x65fc
orb $0x22, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6604
andb $-0x23, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirinternal.c
// Function: sir_syslogopts
bool _sir_syslogopts(sirinit* si, const sir_update_config_data* data) {
    bool updated = _sir_updateopts(SIR_DESTNAME_SYSLOG, &si->d_syslog.opts, data->opts);
    if (updated) {
        _sir_setbitshigh(&si->d_syslog._state.mask, SIRSL_UPDATED | SIRSL_OPTIONS);
        updated = _sir_syslog_updated(si, data);
        _sir_setbitslow(&si->d_syslog._state.mask, SIRSL_UPDATED | SIRSL_OPTIONS);
    }
    return updated;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14(%rdi), %rsi
movq 0x10(%r14), %rdx
leaq 0x356f(%rip), %rdi      # 0x9c09
callq 0x6539
testb %al, %al
je 0x66b6
orb $0x24, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6604
andb $-0x25, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirinternal.c
// Function: sir_syslogid
bool _sir_syslogid(sirinit* si, const sir_update_config_data* data) {
    bool retval = _sir_validptr(si) && _sir_validptr(data);

    if (retval) {
        bool cur_ok = _sir_validstrnofail(si->d_syslog.identity);
        if (!cur_ok || 0 != strncmp(si->d_syslog.identity, data->sl_identity, SIR_MAX_SYSLOG_ID)) {
            _sir_selflog("updating %s identity from '%s' to '%s'", SIR_DESTNAME_SYSLOG,
                si->d_syslog.identity, data->sl_identity);
            (void)_sir_strncpy(si->d_syslog.identity, SIR_MAX_SYSLOG_ID, data->sl_identity,
                strnlen(data->sl_identity, SIR_MAX_SYSLOG_ID));
            _sir_setbitshigh(&si->d_syslog._state.mask, SIRSL_UPDATED | SIRSL_IDENTITY);
            retval = _sir_syslog_updated(si, data);
            _sir_setbitslow(&si->d_syslog._state.mask, SIRSL_UPDATED | SIRSL_IDENTITY);
        } else {
            _sir_selflog("skipped superfluous update of %s identity: '%s'", SIR_DESTNAME_SYSLOG,
                si->d_syslog.identity);
        }
    }

    return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x66dc
testq %r14, %r14
setne %bpl
jne 0x66fb
jmp 0x66de
xorl %ebp, %ebp
leaq 0x352b(%rip), %rsi      # 0x9c10
leaq 0x34ca(%rip), %rdx      # 0x9bb6
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x184, %ecx            # imm = 0x184
callq 0x31c0
testb %bpl, %bpl
je 0x6758
leaq 0x28(%rbx), %r15
cmpb $0x0, 0x28(%rbx)
je 0x671f
movq 0x18(%r14), %rsi
movl $0x80, %edx
movq %r15, %rdi
callq 0x20a0
testl %eax, %eax
je 0x6758
movq 0x18(%r14), %r12
movl $0x80, %esi
movq %r12, %rdi
callq 0x21c0
movl $0x80, %esi
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
callq 0x57c8
orb $0x30, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6604
andb $-0x31, 0x18(%rbx)
jmp 0x675a
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirinternal.c
// Function: sir_syslogcat
bool _sir_syslogcat(sirinit* si, const sir_update_config_data* data) {
    bool retval = _sir_validptr(si) && _sir_validptr(data);

    if (retval) {
        bool cur_ok = _sir_validstrnofail(si->d_syslog.category);
        if (!cur_ok || 0 != strncmp(si->d_syslog.category, data->sl_category, SIR_MAX_SYSLOG_CAT)) {
            _sir_selflog("updating %s category from '%s' to '%s'", SIR_DESTNAME_SYSLOG,
                si->d_syslog.category, data->sl_category);
            (void)_sir_strncpy(si->d_syslog.category, SIR_MAX_SYSLOG_CAT, data->sl_category,
                strnlen(data->sl_category, SIR_MAX_SYSLOG_CAT));
            _sir_setbitshigh(&si->d_syslog._state.mask, SIRSL_UPDATED | SIRSL_CATEGORY);
            retval = _sir_syslog_updated(si, data);
            _sir_setbitslow(&si->d_syslog._state.mask, SIRSL_UPDATED | SIRSL_CATEGORY);
        } else {
            _sir_selflog("skipped superfluous update of %s category: '%s'", SIR_DESTNAME_SYSLOG,
                si->d_syslog.identity);
        }
    }

    return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x6781
testq %r14, %r14
setne %bpl
jne 0x67a0
jmp 0x6783
xorl %ebp, %ebp
leaq 0x3494(%rip), %rsi      # 0x9c1e
leaq 0x3425(%rip), %rdx      # 0x9bb6
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x19a, %ecx            # imm = 0x19A
callq 0x31c0
testb %bpl, %bpl
je 0x6803
leaq 0xa8(%rbx), %r15
cmpb $0x0, 0xa8(%rbx)
je 0x67ca
movq 0x20(%r14), %rsi
movl $0x40, %edx
movq %r15, %rdi
callq 0x20a0
testl %eax, %eax
je 0x6803
movq 0x20(%r14), %r12
movl $0x40, %esi
movq %r12, %rdi
callq 0x21c0
movl $0x40, %esi
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
callq 0x57c8
orb $0x28, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6604
andb $-0x29, 0x18(%rbx)
jmp 0x6805
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirinternal.c
// Function: sir_writeinit
bool _sir_writeinit(const sir_update_config_data* data, sirinit_update update) {
    (void)_sir_seterror(_SIR_E_NOERROR);

    if (!_sir_sanity() || !_sir_validupdatedata(data) || !_sir_validfnptr(update))
        return false;

    _SIR_LOCK_SECTION(sirconfig, _cfg, SIRMI_CONFIG, false);

    bool updated = update(&_cfg->si, data);
    if (!updated)
        _sir_selflog("error: update routine failed!");

    _SIR_UNLOCK_SECTION(SIRMI_CONFIG);
    return updated;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x340e(%rip), %rsi      # 0x9c2d
leaq 0x3390(%rip), %rdx      # 0x9bb6
movl $0x80010000, %edi       # imm = 0x80010000
movl $0x1b0, %ecx            # imm = 0x1B0
callq 0x31c0
movq 0x7ca4(%rip), %rax      # 0xe4e0
cmpq $0x60906090, %rax       # imm = 0x60906090
je 0x6865
leaq 0x3393(%rip), %rsi      # 0x9bde
leaq 0x3364(%rip), %rdx      # 0x9bb6
movl $0x80020000, %edi       # imm = 0x80020000
movl $0x11a, %ecx            # imm = 0x11A
callq 0x31c0
testb %al, %al
je 0x68cf
leaq 0x33c1(%rip), %rsi      # 0x9c2d
leaq 0x3343(%rip), %rdx      # 0x9bb6
movq %r14, %rdi
movl $0x1b2, %ecx            # imm = 0x1B2
callq 0x5579
testb %al, %al
je 0x68cf
leaq 0x7c5d(%rip), %rdi      # 0xe4e8
callq 0x799c
testb %al, %al
je 0x68b2
leaq 0x7c75(%rip), %rdi      # 0xe510
movq %r14, %rsi
callq *%rbx
movl %eax, %ebx
leaq 0x7c3f(%rip), %rdi      # 0xe4e8
callq 0x7a3a
movl %ebx, %eax
jmp 0x68d1
leaq 0x3374(%rip), %rsi      # 0x9c2d
leaq 0x32f6(%rip), %rdx      # 0x9bb6
movl $0x800f0000, %edi       # imm = 0x800F0000
movl $0x1b5, %ecx            # imm = 0x1B5
callq 0x31c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirinternal.c
// Function: sir_formattedlevelstr
const char* _sir_formattedlevelstr(sir_level level) {
    static const size_t low  = 0;
    static const size_t high = SIR_NUMLEVELS - 1;

    const char* retval = SIR_UNKNOWN;

    _SIR_DECLARE_BIN_SEARCH(low, high);
    _SIR_BEGIN_BIN_SEARCH()

    if (sir_level_to_str_map[_mid].level == level) {
        retval = sir_level_to_str_map[_mid].fmt;
        break;
    }

    _SIR_ITERATE_BIN_SEARCH((sir_level_to_str_map[_mid].level < level ? 1 : -1));
    _SIR_END_BIN_SEARCH();

    return retval;
}

// Assembly:
leaq 0x72a8(%rip), %rcx      # 0xe440
movzwl 0x30(%rcx), %r9d
cmpw %di, %r9w
jne 0x71a9
addq $0x30, %rcx
jmp 0x720b
movl $0x7, %r8d
movl $0x3, %edx
xorl %esi, %esi
leaq 0x21ca(%rip), %rax      # 0x9387
cmpq %r8, %rsi
je 0x720f
cmpw %di, %r9w
setb %r9b
leaq -0x1(%rdx), %r10
cmpq %rsi, %r10
setb %r11b
orb %r9b, %r11b
cmpb $0x1, %r11b
jne 0x71ec
cmpq %r8, %rdx
jae 0x720f
incq %rdx
movq %rdx, %rsi
movq %r8, %r10
leaq (%r10,%rsi), %rdx
shrq %rdx
movq %rdx, %r11
shlq $0x4, %r11
movzwl (%rcx,%r11), %r9d
movq %r10, %r8
cmpw %di, %r9w
jne 0x71bd
addq %r11, %rcx
movq 0x8(%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirmutex.c
// Function: sir_mutexlock
bool _sir_mutexlock(sir_mutex* mutex) {
    if (_sir_validptr(mutex)) {
        int op = pthread_mutex_lock(mutex);
        return 0 == op ? true : _sir_handleerr(op);
    }

    return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x79c6
callq 0x2470
testl %eax, %eax
je 0x79e7
leaq 0x243a(%rip), %rsi      # 0x9dec
leaq 0x2428(%rip), %rdx      # 0x9de1
movl %eax, %edi
movl $0x3c, %ecx
popq %rax
jmp 0x32bc
leaq 0x241f(%rip), %rsi      # 0x9dec
leaq 0x240d(%rip), %rdx      # 0x9de1
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x3a, %ecx
callq 0x31c0
xorl %eax, %eax
jmp 0x79e9
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirmutex.c
// Function: sir_mutextrylock
bool _sir_mutextrylock(sir_mutex* mutex) {
    if (_sir_validptr(mutex)) {
        int op = pthread_mutex_trylock(mutex);
        return 0 == op ? true : _sir_handleerr(op);
    }

    return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x7a15
callq 0x21e0
testl %eax, %eax
je 0x7a36
leaq 0x23fa(%rip), %rsi      # 0x9dfb
leaq 0x23d9(%rip), %rdx      # 0x9de1
movl %eax, %edi
movl $0x45, %ecx
popq %rax
jmp 0x32bc
leaq 0x23df(%rip), %rsi      # 0x9dfb
leaq 0x23be(%rip), %rdx      # 0x9de1
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x43, %ecx
callq 0x31c0
xorl %eax, %eax
jmp 0x7a38
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirmutex.c
// Function: sir_mutexunlock
bool _sir_mutexunlock(sir_mutex* mutex) {
    if (_sir_validptr(mutex)) {
        int op = pthread_mutex_unlock(mutex);
        return 0 == op ? true : _sir_handleerr(op);
    }

    return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x7a64
callq 0x22f0
testl %eax, %eax
je 0x7a85
leaq 0x23bd(%rip), %rsi      # 0x9e0d
leaq 0x238a(%rip), %rdx      # 0x9de1
movl %eax, %edi
movl $0x4e, %ecx
popq %rax
jmp 0x32bc
leaq 0x23a2(%rip), %rsi      # 0x9e0d
leaq 0x236f(%rip), %rdx      # 0x9de1
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x4c, %ecx
callq 0x31c0
xorl %eax, %eax
jmp 0x7a87
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirmutex.c
// Function: sir_mutexdestroy
bool _sir_mutexdestroy(sir_mutex* mutex) {
    if (_sir_validptr(mutex)) {
        int op = pthread_mutex_destroy(mutex);
        return 0 == op ? true : _sir_handleerr(op);
    }

    return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x7ab3
callq 0x2160
testl %eax, %eax
je 0x7ad4
leaq 0x237f(%rip), %rsi      # 0x9e1e
leaq 0x233b(%rip), %rdx      # 0x9de1
movl %eax, %edi
movl $0x57, %ecx
popq %rax
jmp 0x32bc
leaq 0x2364(%rip), %rsi      # 0x9e1e
leaq 0x2320(%rip), %rdx      # 0x9de1
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x55, %ecx
callq 0x31c0
xorl %eax, %eax
jmp 0x7ad6
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirplugins.c
// Function: sir_plugin_load
sirpluginid _sir_plugin_load(const char* path) {
#if !defined(SIR_NO_PLUGINS)
    (void)_sir_seterror(_SIR_E_NOERROR);

    if (!_sir_sanity() || !_sir_validstr(path))
        return 0U;

    sir_plugin* plugin = (sir_plugin*)calloc(1, sizeof(sir_plugin));
    if (!plugin)
        return _sir_handleerr(errno);

# if !defined (__WIN__)
    plugin->handle = dlopen(path, RTLD_NOW | RTLD_LOCAL);
    if (!plugin->handle) {
        const char* err = dlerror();
        _sir_selflog("error: dlopen('%s') failed (%s)", path, _SIR_PRNSTR(err));
        _sir_plugin_destroy(&plugin);
        return _sir_handleerr(errno);
    }
# else /* __WIN__ */
    UINT old_error_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
    plugin->handle      = LoadLibraryA(path);
    SetErrorMode(old_error_mode);
    if (!plugin->handle) {
        DWORD err = GetLastError();
        _sir_selflog("error: LoadLibraryA(%s) failed (%lu)", path, err);
        _sir_plugin_destroy(&plugin);
        return _sir_handlewin32err(err);
    }
# endif

    plugin->loaded = true;
    plugin->path   = strndup(path, strnlen(path, SIR_MAXPATH));

    if (!_sir_validstrnofail(plugin->path)) {
        _sir_plugin_destroy(&plugin);
        return _sir_handleerr(errno);
    }

    _sir_selflog("loaded plugin (path: '%s', addr: %p); probing...", //-V576
        plugin->path, plugin->handle);

    return _sir_plugin_probe(plugin);
#else
    SIR_UNUSED(path);
    return 0U;
#endif
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2346(%rip), %rsi      # 0x9e30
leaq 0x2350(%rip), %rdx      # 0x9e41
movl $0x80010000, %edi       # imm = 0x80010000
movl $0x25, %ecx
callq 0x31c0
xorl %ebp, %ebp
callq 0x6430
testb %al, %al
je 0x7c21
testq %rbx, %rbx
je 0x7b8f
cmpb $0x0, (%rbx)
je 0x7b8f
movl $0x1, %edi
movl $0x68, %esi
callq 0x2220
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x7bae
movq %rbx, %rdi
movl $0x2, %esi
callq 0x2240
movq 0x8(%rsp), %r14
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x7bf0
movb $0x1, 0x38(%r14)
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
callq 0x21c0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2200
movq %rax, (%r14)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x7bca
cmpb $0x0, (%rax)
je 0x7bca
callq 0x7c72
movl %eax, %ebp
jmp 0x7c21
leaq 0x229a(%rip), %rsi      # 0x9e30
leaq 0x22a4(%rip), %rdx      # 0x9e41
movl $0x800a0000, %edi       # imm = 0x800A0000
movl $0x27, %ecx
callq 0x31c0
jmp 0x7c21
callq 0x2080
movl (%rax), %edi
leaq 0x2274(%rip), %rsi      # 0x9e30
leaq 0x227e(%rip), %rdx      # 0x9e41
movl $0x2c, %ecx
jmp 0x7c19
leaq 0x8(%rsp), %rdi
callq 0x7c2c
callq 0x2080
movl (%rax), %edi
leaq 0x224e(%rip), %rsi      # 0x9e30
leaq 0x2258(%rip), %rdx      # 0x9e41
movl $0x47, %ecx
jmp 0x7c19
callq 0x2050
leaq 0x8(%rsp), %rdi
callq 0x7c2c
callq 0x2080
movl (%rax), %edi
leaq 0x2223(%rip), %rsi      # 0x9e30
leaq 0x222d(%rip), %rdx      # 0x9e41
movl $0x34, %ecx
callq 0x32bc
movzbl %al, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirplugins.c
// Function: sir_plugin_rem
bool _sir_plugin_rem(sirpluginid id) {
#if !defined(SIR_NO_PLUGINS)
    (void)_sir_seterror(_SIR_E_NOERROR);

    if (!_sir_sanity())
        return false;

    _SIR_LOCK_SECTION(sir_plugincache, spc, SIRMI_PLUGINCACHE, false);
    bool retval = _sir_plugin_cache_rem(spc, id);
    _SIR_UNLOCK_SECTION(SIRMI_PLUGINCACHE);

    return retval;
#else
    SIR_UNUSED(id);
    return false;
#endif
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leaq 0x1e39(%rip), %rsi      # 0x9ede
leaq 0x1d95(%rip), %rdx      # 0x9e41
movl $0x80010000, %edi       # imm = 0x80010000
movl $0x132, %ecx            # imm = 0x132
callq 0x31c0
callq 0x6430
testb %al, %al
je 0x810a
movl $0x2, %edi
callq 0x6064
testq %rax, %rax
je 0x80ed
movq %rax, %rdi
movl %ebx, %esi
callq 0x810e
movl %eax, %ebx
movl $0x2, %edi
callq 0x6248
movl %ebx, %eax
jmp 0x810c
leaq 0x1dea(%rip), %rsi      # 0x9ede
leaq 0x1d46(%rip), %rdx      # 0x9e41
movl $0x800f0000, %edi       # imm = 0x800F0000
movl $0x137, %ecx            # imm = 0x137
callq 0x31c0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirplugins.c
// Function: sir_plugin_cache_find_id
sir_plugin* _sir_plugin_cache_find_id(const sir_plugincache* spc, sirpluginid id) {
#if !defined(SIR_NO_PLUGINS)
    return _sir_plugin_cache_find(spc, &id, &_sir_plugin_cache_pred_id);
#else
    SIR_UNUSED(spc);
    SIR_UNUSED(id);
    return NULL;
#endif
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x8216
movq 0x80(%rdi), %rcx
testq %rcx, %rcx
je 0x8233
xorl %edx, %edx
movq (%rdi,%rdx,8), %rax
cmpl %esi, 0x60(%rax)
je 0x8235
incq %rdx
cmpq %rdx, %rcx
jne 0x8203
jmp 0x8233
leaq 0x1cfb(%rip), %rsi      # 0x9f18
leaq 0x1c1d(%rip), %rdx      # 0x9e41
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x184, %ecx            # imm = 0x184
callq 0x31c0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirplugins.c
// Function: sir_plugin_cache_destroy
bool _sir_plugin_cache_destroy(sir_plugincache* spc) {
#if !defined(SIR_NO_PLUGINS)
    if (!_sir_validptr(spc))
        return false;

    while (spc->count > 0) {
        size_t idx = spc->count - 1;
        _sir_plugin_destroy(&spc->plugins[idx]);
        spc->plugins[idx] = NULL;
        spc->count--;
    }

    (void)memset(spc, 0, sizeof(sir_plugincache));
    return true;
#else
    SIR_UNUSED(spc);
    return false;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x8303
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x82f2
leaq (%rbx,%rax,8), %r14
addq $-0x8, %r14
movq %r14, %rdi
callq 0x7c2c
movq $0x0, (%r14)
movq 0x80(%rbx), %rax
decq %rax
movq %rax, 0x80(%rbx)
jne 0x82c8
movl $0x88, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x21b0
jmp 0x8320
leaq 0x1c3b(%rip), %rsi      # 0x9f45
leaq 0x1b30(%rip), %rdx      # 0x9e41
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x1b5, %ecx            # imm = 0x1B5
callq 0x31c0
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirtextstyle.c
// Function: sir_gettextstyle
const char* _sir_gettextstyle(sir_level level) {
    static const size_t low  = 0;
    static const size_t high = SIR_NUMLEVELS - 1;

    _SIR_LOCK_SECTION(sir_text_style_data, data, SIRMI_TEXTSTYLE, NULL);
    const char* retval = SIR_UNKNOWN;

    _SIR_DECLARE_BIN_SEARCH(low, high);
    _SIR_BEGIN_BIN_SEARCH()

    if (data->map[_mid].level == level) {
        retval = data->map[_mid].str;
        break;
    }

    _SIR_ITERATE_BIN_SEARCH((data->map[_mid].level < level ? 1 : -1));
    _SIR_END_BIN_SEARCH();
    _SIR_UNLOCK_SECTION(SIRMI_TEXTSTYLE);

    return retval;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x3, %edi
callq 0x6064
testq %rax, %rax
je 0x84a3
movq (%rax), %rax
movzwl 0xb4(%rax), %edi
cmpw %bp, %di
jne 0x84c4
addq $0xb4, %rax
jmp 0x8513
leaq 0x1b52(%rip), %rsi      # 0x9ffc
leaq 0x1b5d(%rip), %rdx      # 0xa00e
movl $0x800f0000, %edi       # imm = 0x800F0000
movl $0x33, %ecx
callq 0x31c0
xorl %ebx, %ebx
jmp 0x8524
movl $0x7, %esi
movl $0x3, %ecx
xorl %edx, %edx
leaq 0xeb0(%rip), %rbx       # 0x9387
cmpq %rsi, %rdx
je 0x851a
cmpw %bp, %di
jb 0x84ea
leaq -0x1(%rcx), %r8
cmpq %rdx, %r8
jae 0x84f8
cmpq %rsi, %rcx
jae 0x851a
incq %rcx
movq %rcx, %rdx
movq %rsi, %r8
leaq (%r8,%rdx), %rcx
shrq %rcx
imulq $0x3c, %rcx, %r9
movzwl (%rax,%r9), %edi
movq %r8, %rsi
cmpw %bp, %di
jne 0x84d7
addq %r9, %rax
movq %rax, %rbx
addq $0x10, %rbx
movl $0x3, %edi
callq 0x6248
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirtextstyle.c
// Function: sir_settextstyle
bool _sir_settextstyle(sir_level level, const sir_textstyle* style) {
    (void)_sir_seterror(_SIR_E_NOERROR);

    if (!_sir_sanity() || !_sir_validlevel(level))
        return false;

    _SIR_LOCK_SECTION(sir_text_style_data, data, SIRMI_TEXTSTYLE, false);
    bool updated              = false;
    static const size_t low   = 0;
    static const size_t high  = SIR_NUMLEVELS - 1;

    _SIR_DECLARE_BIN_SEARCH(low, high);
    _SIR_BEGIN_BIN_SEARCH()

    if (data->map[_mid].level == level) {
        (void)memcpy(&data->map[_mid].style, style, sizeof(sir_textstyle));
        updated = _sir_formatstyle(*data->color_mode, style, data->map[_mid].str);
        break;
    }

    _SIR_ITERATE_BIN_SEARCH((data->map[_mid].level < level ? 1 : -1));
    _SIR_END_BIN_SEARCH();
    _SIR_UNLOCK_SECTION(SIRMI_TEXTSTYLE);

    SIR_ASSERT(updated);
    return updated;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1ae0(%rip), %rsi      # 0xa01d
leaq 0x1aca(%rip), %rdx      # 0xa00e
movl $0x80010000, %edi       # imm = 0x80010000
movl $0x46, %ecx
callq 0x31c0
callq 0x6430
testb %al, %al
je 0x85c6
movzwl %bp, %edi
leaq 0x1ab7(%rip), %rsi      # 0xa01d
leaq 0x1aa1(%rip), %rdx      # 0xa00e
movl $0x48, %ecx
callq 0x56f7
testb %al, %al
je 0x85c6
movl $0x3, %edi
callq 0x6064
testq %rax, %rax
je 0x85a9
movq (%rax), %rcx
movzwl 0xb4(%rcx), %r8d
cmpw %bp, %r8w
jne 0x85d1
addq $0xb4, %rcx
movl $0x3, %edx
jmp 0x861b
leaq 0x1a6d(%rip), %rsi      # 0xa01d
leaq 0x1a57(%rip), %rdx      # 0xa00e
movl $0x800f0000, %edi       # imm = 0x800F0000
movl $0x4b, %ecx
callq 0x31c0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x7, %edi
movl $0x3, %edx
xorl %esi, %esi
cmpq %rdi, %rsi
je 0x8649
cmpw %bp, %r8w
jb 0x85f1
leaq -0x1(%rdx), %r9
cmpq %rsi, %r9
jae 0x85ff
cmpq %rdi, %rdx
jae 0x8649
incq %rdx
movq %rdx, %rsi
movq %rdi, %r9
leaq (%r9,%rsi), %rdx
shrq %rdx
imulq $0x3c, %rdx, %r10
movzwl (%rcx,%r10), %r8d
movq %r9, %rdi
cmpw %bp, %r8w
jne 0x85dd
addq %r10, %rcx
movl 0x8(%rbx), %esi
movl %esi, 0xc(%rcx)
movq (%rbx), %rsi
movq %rsi, 0x4(%rcx)
movq (%rax), %rcx
movq 0x8(%rax), %rax
movl (%rax), %edi
imulq $0x3c, %rdx, %rax
leaq (%rcx,%rax), %rdx
addq $0x10, %rdx
movq %rbx, %rsi
callq 0x865a
movl %eax, %ebx
jmp 0x864b
xorl %ebx, %ebx
movl $0x3, %edi
callq 0x6248
jmp 0x85c8
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirtextstyle.c
// Function: sir_getdefstyle
const sir_textstyle* _sir_getdefstyle(sir_level level) {
    switch (level) {
        case SIRL_EMERG:  return &sir_lvl_emerg_def_style;
        case SIRL_ALERT:  return &sir_lvl_alert_def_style;
        case SIRL_CRIT:   return &sir_lvl_crit_def_style;
        case SIRL_ERROR:  return &sir_lvl_error_def_style;
        case SIRL_WARN:   return &sir_lvl_warn_def_style;
        case SIRL_NOTICE: return &sir_lvl_notice_def_style;
        case SIRL_INFO:   return &sir_lvl_info_def_style;
        case SIRL_DEBUG:  return &sir_lvl_debug_def_style;
        // GCOVR_EXCL_START
        default: /* this should never happen */
            SIR_ASSERT(level);
            return &sir_lvl_info_def_style;
        // GCOVR_EXCL_STOP
    }
}

// Assembly:
cmpl $0xf, %edi
jg 0x8887
decl %edi
cmpl $0x7, %edi
ja 0x88b3
leaq 0x1706(%rip), %rax      # 0x9f7c
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x1716(%rip), %rax      # 0x9f9c
retq
cmpl $0x3f, %edi
jg 0x889e
cmpl $0x10, %edi
je 0x88d3
cmpl $0x20, %edi
jne 0x88b3
leaq 0x173b(%rip), %rax      # 0x9fd8
retq
cmpl $0x40, %edi
je 0x88b3
cmpl $0x80, %edi
jne 0x88b3
leaq 0x173e(%rip), %rax      # 0x9ff0
retq
leaq 0x172a(%rip), %rax      # 0x9fe4
retq
leaq 0x16fe(%rip), %rax      # 0x9fc0
retq
leaq 0x16de(%rip), %rax      # 0x9fa8
retq
leaq 0x16e2(%rip), %rax      # 0x9fb4
retq
leaq 0x16f2(%rip), %rax      # 0x9fcc
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirtextstyle.c
// Function: sir_resettextstyles
bool _sir_resettextstyles(void) {
    (void)_sir_seterror(_SIR_E_NOERROR);

    if (!_sir_sanity())
        return false;

    _SIR_LOCK_SECTION(sir_text_style_data, data, SIRMI_TEXTSTYLE, false);
    bool all_ok = true;
    for (size_t n = 0; n < SIR_NUMLEVELS; n++) {
        (void)memcpy(&data->map[n].style, _sir_getdefstyle(data->map[n].level),
             sizeof(sir_textstyle));
        _sir_eqland(all_ok, _sir_formatstyle(*data->color_mode, &data->map[n].style,
            data->map[n].str));
    }

    _SIR_UNLOCK_SECTION(SIRMI_TEXTSTYLE);
    return all_ok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1745(%rip), %rsi      # 0xa02f
leaq 0x171d(%rip), %rdx      # 0xa00e
movl $0x80010000, %edi       # imm = 0x80010000
movl $0x74, %ecx
callq 0x31c0
callq 0x6430
testb %al, %al
je 0x8996
movl $0x3, %edi
callq 0x6064
testq %rax, %rax
je 0x8979
movq %rax, %r14
movb $0x1, %bl
movl $0x10, %r15d
movq (%r14), %r12
movzwl -0x10(%r12,%r15), %edi
callq 0x8863
movq (%rax), %rcx
movq %rcx, -0xc(%r12,%r15)
movl 0x8(%rax), %eax
movl %eax, -0x4(%r12,%r15)
movq (%r14), %rdx
movq 0x8(%r14), %rax
movl (%rax), %edi
leaq (%rdx,%r15), %rsi
addq $-0xc, %rsi
addq %r15, %rdx
callq 0x865a
andb %al, %bl
addq $0x3c, %r15
cmpq $0x1f0, %r15            # imm = 0x1F0
jne 0x8927
movl $0x3, %edi
callq 0x6248
jmp 0x8998
leaq 0x16af(%rip), %rsi      # 0xa02f
leaq 0x1687(%rip), %rdx      # 0xa00e
movl $0x800f0000, %edi       # imm = 0x800F0000
movl $0x79, %ecx
callq 0x31c0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/src/sirtextstyle.c
// Function: sir_setcolormode
bool _sir_setcolormode(sir_colormode mode) {
    if (!_sir_validcolormode(mode))
        return false;

    _SIR_LOCK_SECTION(sir_text_style_data, data, SIRMI_TEXTSTYLE, false);
    if (*data->color_mode != mode) {
        sir_colormode old = *data->color_mode;
        *data->color_mode = mode;
        _sir_selflog("color mode changed from %"PRId32" to %"PRId32, old, mode);

        /* when the color mode changes, it's necessary to regenerate the text styles
         * we're holding. for example in the case of downgrading color modes, the
         * styles in memory could be incompatible with the new mode. */
        if (!_sir_resettextstyles()) {
            _sir_selflog("error: failed to reset text styles!");
            _SIR_UNLOCK_SECTION(SIRMI_TEXTSTYLE);
            return false;
        }
    } else {
        _sir_selflog("skipped superfluous update of color mode: %"PRId32, mode);
    }
    _SIR_UNLOCK_SECTION(SIRMI_TEXTSTYLE);

    return true;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leaq 0x15a1(%rip), %rsi      # 0xa09f
leaq 0x1509(%rip), %rdx      # 0xa00e
movl $0xc4, %ecx
callq 0x57b6
testb %al, %al
je 0x8b6c
movl $0x3, %edi
callq 0x6064
testq %rax, %rax
je 0x8b43
movq 0x8(%rax), %rax
cmpl %ebx, (%rax)
je 0x8b35
movl %ebx, (%rax)
callq 0x88db
testb %al, %al
je 0x8b62
movl $0x3, %edi
callq 0x6248
movb $0x1, %al
jmp 0x8b6e
leaq 0x1555(%rip), %rsi      # 0xa09f
leaq 0x14bd(%rip), %rdx      # 0xa00e
movl $0x800f0000, %edi       # imm = 0x800F0000
movl $0xc7, %ecx
callq 0x31c0
jmp 0x8b6c
movl $0x3, %edi
callq 0x6248
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_fcollect32.c
// Function: shmem_fcollect32
void shmem_fcollect32(void *dest, const void *source, size_t nelems, 
	int pe_start, int log_pe_stride, int pe_size, long* psync)
{
	const int step = 1 << log_pe_stride;
	const int pe_shift = pe_size << log_pe_stride;
	const int pe_end = pe_start + pe_shift;
	const int my_pe = __shmem.my_pe;

	const int nbytes = nelems << 2;

	const ptrdiff_t offset = nbytes * ((my_pe - pe_start) >> log_pe_stride);
	const void* target = (void*)((intptr_t)dest + offset);

	int pe = my_pe;

	do {
		shmemx_memcpy(shmem_ptr(target,pe), source, nelems*sizeof(int32_t));
		pe += step;
	} while (pe < pe_end);

	pe -= pe_shift;
	while (pe < my_pe) {
		shmemx_memcpy(shmem_ptr(target,pe), source, nelems*sizeof(int32_t));
		pe += step;
	}
	shmem_barrier(pe_start, log_pe_stride, pe_size, psync);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r10d
movq %rdx, %r15
movq %rsi, %r12
movl $0x1, %r14d
movl %r8d, %ecx
shll %cl, %r14d
movl %r9d, 0xc(%rsp)
movl %r9d, %edx
shll %cl, %edx
leaq 0x3194(%rip), %rax      # 0x61f0
movl 0x4(%rax), %ebx
movl %ebx, %eax
subl %r10d, %eax
movl %r8d, 0x8(%rsp)
sarl %cl, %eax
movq 0x60(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rdx, 0x10(%rsp)
leal (%rdx,%r10), %ebp
imull %r15d, %eax
shll $0x2, %eax
movslq %eax, %r13
addq %rdi, %r13
shlq $0x2, %r15
movl %ebx, 0x4(%rsp)
movq %r13, %rdi
movl %ebx, %esi
callq 0x1cec
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x31b4
addl %r14d, %ebx
cmpl %ebp, %ebx
jl 0x3098
subl 0x10(%rsp), %ebx
movl 0x4(%rsp), %ebp
cmpl %ebp, %ebx
jge 0x30e0
movq %r13, %rdi
movl %ebx, %esi
callq 0x1cec
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x31b4
addl %r14d, %ebx
jmp 0x30bf
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
movq 0x18(%rsp), %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3108
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/src/test_vec_comp.c
// Function: init_data
void
init_data (vl_size numDimensions, vl_size numSamples, float ** X, float ** Y)
{
  VlRand * rand = vl_get_rand() ;
  vl_uindex i ;
  float * Xi = *X = vl_malloc(sizeof(float) * numDimensions * numSamples) ;
  float * Yi = *Y = vl_malloc(sizeof(float) * numDimensions * numSamples) ;
  for (i = 0 ; i < numDimensions * numSamples ; ++ i) {
    *Xi++ = vl_rand_real1(rand) ;
    *Yi++ = vl_rand_real1(rand) ;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x10b0
movq %rax, %r14
imulq %r15, %rbx
leaq (,%rbx,4), %rbp
movq %rbp, %rdi
callq 0x1080
movq %rax, %r15
movq %rax, (%r12)
movq %rbp, %rdi
callq 0x1080
movq %rax, (%r13)
testq %rbx, %rbx
je 0x1271
movq %rax, %r12
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x1060
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0xdd1(%rip), %xmm1      # 0x2008
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r15,%r13,4)
movq %r14, %rdi
callq 0x1060
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0xda9(%rip), %xmm0      # 0x2008
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r12,%r13,4)
incq %r13
cmpq %r13, %rbx
jne 0x121d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/src/test_vec_comp.c
// Function: main
int
main (int argc VL_UNUSED, char** argv VL_UNUSED)
{
  float * X ;
  float * Y ;
  vl_size numDimensions = 1000 ;
  vl_size numSamples    = 2000 ;
  float * result = vl_malloc (sizeof(float) * numSamples * numSamples) ;
  VlFloatVectorComparisonFunction f ;

  init_data (numDimensions, numSamples, &X, &Y) ;

  X+=1 ;
  Y+=1 ;

  vl_set_simd_enabled (VL_FALSE) ;
  f = vl_get_vector_comparison_function_f (VlDistanceL2) ;
  vl_tic () ;
  vl_eval_vector_comparison_on_all_pairs_f (result, numDimensions, X, numSamples, Y, numSamples, f) ;
  VL_PRINTF("Float L2 distnace: %.3f s\n", vl_toc ()) ;

  vl_set_simd_enabled (VL_TRUE) ;
  f = vl_get_vector_comparison_function_f (VlDistanceL2) ;
  vl_tic () ;
  vl_eval_vector_comparison_on_all_pairs_f (result, numDimensions, X, numSamples, Y, numSamples, f) ;
  VL_PRINTF("Float L2 distance (SIMD): %.3f s\n", vl_toc ()) ;

  X-- ;
  Y-- ;

  vl_free (X) ;
  vl_free (Y) ;
  vl_free (result) ;

  return 0 ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xf42400, %edi         # imm = 0xF42400
callq 0x1080
movq %rax, %rbx
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movl $0x3e8, %edi            # imm = 0x3E8
movl $0x7d0, %esi            # imm = 0x7D0
movq %r14, %rdx
movq %r15, %rcx
callq 0x11cc
movq (%r14), %r13
leaq 0x4(%r13), %rbp
movq %rbp, (%r14)
movq (%r15), %r12
leaq 0x4(%r12), %r14
movq %r14, (%r15)
xorl %edi, %edi
callq 0x1090
movl $0x1, %edi
callq 0x10a0
movq %rax, %r15
callq 0x1030
movq %r15, (%rsp)
movl $0x3e8, %esi            # imm = 0x3E8
movl $0x7d0, %ecx            # imm = 0x7D0
movl $0x7d0, %r9d            # imm = 0x7D0
movq %rbx, %rdi
movq %rbp, %rdx
movq %r14, %r8
callq 0x10c0
callq 0x1040
movq %rax, %r15
callq 0x1050
leaq 0xcf2(%rip), %rdi       # 0x2010
movb $0x1, %al
callq *%r15
movl $0x1, %edi
callq 0x1090
movl $0x1, %edi
callq 0x10a0
movq %rax, %r15
callq 0x1030
movq %r15, (%rsp)
movl $0x3e8, %esi            # imm = 0x3E8
movl $0x7d0, %ecx            # imm = 0x7D0
movl $0x7d0, %r9d            # imm = 0x7D0
movq %rbx, %rdi
movq %rbp, %rdx
movq %r14, %r8
callq 0x10c0
callq 0x1040
movq %rax, %r14
callq 0x1050
leaq 0xcb6(%rip), %rdi       # 0x202b
movb $0x1, %al
callq *%r14
leaq 0x10(%rsp), %rax
movq %r13, (%rax)
leaq 0x8(%rsp), %rax
movq %r12, (%rax)
movq %r13, %rdi
callq 0x1070
movq %r12, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1070
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/basic.c
// Function: getgoal
long getgoal (LINE *dlp)
{
  int col, newcol, dbo, c;

  col = 0;
  dbo = 0;
  while (dbo != llength (dlp))
    {
      c = lgetc (dlp, dbo);
      newcol = col;
      if (c == '\t')
	newcol |= 0x07;
      else if (c < 0x20 || c == 0x7F)
	++newcol;
      ++newcol;
      if (newcol > curgoal)
	break;
      col = newcol;
      ++dbo;
    }
  return (dbo);
}

// Assembly:
movl 0x14(%rdi), %ecx
xorl %eax, %eax
testq %rcx, %rcx
je 0x23dd
leaq 0xb78b(%rip), %rdx      # 0xdb28
movl (%rdx), %esi
xorl %edx, %edx
movb 0x18(%rdi,%rdx), %r8b
cmpb $0x9, %r8b
jne 0x23b1
orl $0x7, %eax
jmp 0x23cb
cmpb $0x20, %r8b
setb %r9b
cmpb $0x7f, %r8b
sete %r8b
orb %r9b, %r8b
movzbl %r8b, %r8d
addl %r8d, %eax
cmpl %esi, %eax
jge 0x23db
incl %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x23a1
movl %ecx, %edx
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/basic.c
// Function: backchar
int backchar (int f, int n)
{
  LINE *lp;

  if (n < 0)
    return (forwchar (f, -n));
  while (n--)
    {
      if (curwp->w_doto == 0)
	{
	  if ((lp = lback (curwp->w_dotp)) == curbp->b_linep)
	    return (FALSE);
	  curwp->w_dotp = lp;
	  curwp->w_doto = llength (lp);
	  curwp->w_flag |= WFMOVE;
	}
      else
	curwp->w_doto--;
    }
  return (TRUE);
}

// Assembly:
testl %esi, %esi
js 0x2466
movl $0x1, %eax
je 0x2465
leaq 0xb624(%rip), %rcx      # 0xda48
movq (%rcx), %rcx
leaq 0xb60a(%rip), %rdx      # 0xda38
movq (%rdx), %rdx
movq 0x20(%rcx), %rdi
testq %rdi, %rdi
je 0x2443
decq %rdi
movq %rdi, 0x20(%rcx)
jmp 0x2461
movq 0x18(%rcx), %rdi
movq 0x8(%rdi), %rdi
cmpq 0x28(%rdx), %rdi
je 0x246d
movq %rdi, 0x18(%rcx)
movslq 0x14(%rdi), %rdi
movq %rdi, 0x20(%rcx)
orb $0x2, 0x3b(%rcx)
decl %esi
jne 0x2435
retq
negl %esi
jmp 0x2470
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/basic.c
// Function: forwchar
int forwchar (int f, int n)
{
  if (n < 0)
    return (backchar (f, -n));
  while (n--)
    {
      if (curwp->w_doto == llength (curwp->w_dotp))
	{
	  if (curwp->w_dotp == curbp->b_linep)
	    return (FALSE);
	  curwp->w_dotp = lforw (curwp->w_dotp);
	  curwp->w_doto = 0;
	  curwp->w_flag |= WFMOVE;
	}
      else
	curwp->w_doto++;
    }
  return (TRUE);
}

// Assembly:
testl %esi, %esi
js 0x24ca
movl $0x1, %eax
je 0x24c9
leaq 0xb5c6(%rip), %rcx      # 0xda48
movq (%rcx), %rcx
leaq 0xb5ac(%rip), %rdx      # 0xda38
movq (%rdx), %rdx
movq 0x18(%rcx), %rdi
movq 0x20(%rcx), %r8
movslq 0x14(%rdi), %r9
cmpq %r9, %r8
jne 0x24be
cmpq 0x28(%rdx), %rdi
je 0x24d1
movq (%rdi), %rdi
movq %rdi, 0x18(%rcx)
movq $0x0, 0x20(%rcx)
orb $0x2, 0x3b(%rcx)
xorl %r8d, %r8d
jmp 0x24c5
incq %r8
movq %r8, 0x20(%rcx)
decl %esi
jne 0x2497
retq
negl %esi
jmp 0x2412
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/basic.c
// Function: gotoline
int gotoline (int f, int n)
{
  char buf[10];
  char *ep;
  int l,s;

  if ((s = mlreplyt("Goto Line: ", buf, sizeof(buf), '\n')) != TRUE )
	  return s;

  if (buf[0] == '\0')
	return (ABORT);

  l = (int)strtoll(buf, &ep, 10);

  if (buf == ep || *ep != '\0' || n < 1) 
	{
	  mlwrite("Error");
	  return (FALSE);
	}

  /* first, we go to the start of the buffer */
  curwp->w_dotp = lforw (curbp->b_linep);
  curwp->w_doto = 0;
  return (forwline (f, l - 1));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movl %edi, %ebx
leaq 0x6b1b(%rip), %rdi      # 0x9004
leaq 0x6(%rsp), %r14
movq %r14, %rsi
movl $0xa, %edx
movl $0xa, %ecx
callq 0x4503
movl %eax, %r15d
cmpl $0x1, %eax
jne 0x258c
cmpb $0x0, 0x6(%rsp)
je 0x2586
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x2190
movq (%r15), %rcx
cmpq %rcx, %r14
je 0x2573
testl %ebp, %ebp
jle 0x2573
cmpb $0x0, (%rcx)
jne 0x2573
leaq 0xb4f8(%rip), %rcx      # 0xda38
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
movq (%rcx), %rcx
leaq 0xb4f7(%rip), %rdx      # 0xda48
movq (%rdx), %rdx
movq %rcx, 0x18(%rdx)
movq $0x0, 0x20(%rdx)
decl %eax
movl %ebx, %edi
movl %eax, %esi
callq 0x259a
movl $0x1, %r15d
jmp 0x258c
leaq 0x6a96(%rip), %rdi      # 0x9010
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x43cc
jmp 0x258c
movl $0x2, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/basic.c
// Function: forwline
int forwline (int f, int n)
{
  LINE *dlp;

  if (n < 0)
    return (backline (f, -n));
  if ((lastflag & CFCPCN) == 0)/* Reset goal if last */
    curgoal = getccol (FALSE); /* not C-P or C-N */
  thisflag |= CFCPCN;
  dlp = curwp->w_dotp;
  while (n-- && dlp != curbp->b_linep)
    dlp = lforw (dlp);
  curwp->w_dotp = dlp;
  curwp->w_doto = getgoal (dlp);
  curwp->w_flag |= WFMOVE;
  return (TRUE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %esi, %esi
js 0x2605
leaq 0xb495(%rip), %rax      # 0xda40
testb $0x1, (%rax)
jne 0x25c0
xorl %edi, %edi
callq 0x622a
leaq 0xb56a(%rip), %rcx      # 0xdb28
movl %eax, (%rcx)
leaq 0xb4a1(%rip), %rax      # 0xda68
orb $0x1, (%rax)
leaq 0xb477(%rip), %rax      # 0xda48
movq (%rax), %r14
leaq 0x18(%r14), %rdi
leaq 0xb459(%rip), %rax      # 0xda38
movq (%rax), %rax
incl %ebx
movq (%rdi), %rdi
decl %ebx
je 0x25f1
cmpq 0x28(%rax), %rdi
jne 0x25e4
movq %rdi, 0x18(%r14)
callq 0x238c
movq %rax, 0x20(%r14)
orb $0x2, 0x3b(%r14)
jmp 0x260e
negl %ebx
movl %ebx, %esi
callq 0x267a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/basic.c
// Function: gotobob
int gotobob (int f, int n)
{
  curwp->w_dotp = lforw (curbp->b_linep);
  curwp->w_doto = 0;
  curwp->w_flag |= WFHARD;
  return (TRUE);
}

// Assembly:
leaq 0xb416(%rip), %rax      # 0xda38
movq (%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
leaq 0xb415(%rip), %rcx      # 0xda48
movq (%rcx), %rcx
movq %rax, 0x18(%rcx)
movq $0x0, 0x20(%rcx)
orb $0x8, 0x3b(%rcx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/basic.c
// Function: gotoeob
int gotoeob (int f, int n)
{
  curwp->w_dotp = curbp->b_linep;
  curwp->w_doto = 0;
  curwp->w_flag |= WFHARD;
  return (TRUE);
}

// Assembly:
leaq 0xb3e5(%rip), %rax      # 0xda38
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0xb3e7(%rip), %rcx      # 0xda48
movq (%rcx), %rcx
movq %rax, 0x18(%rcx)
movq $0x0, 0x20(%rcx)
orb $0x8, 0x3b(%rcx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/basic.c
// Function: backline
int backline (int f, int n)
{
  LINE *dlp;

  if (n < 0)
    return (forwline (f, -n));
  if ((lastflag & CFCPCN) == 0)/* Reset goal if the */
    curgoal = getccol (FALSE); /* last isn't C-P, C-N */
  thisflag |= CFCPCN;
  dlp = curwp->w_dotp;
  while (n-- && lback (dlp) != curbp->b_linep)
    dlp = lback (dlp);
  curwp->w_dotp = dlp;
  curwp->w_doto = getgoal (dlp);
  curwp->w_flag |= WFMOVE;
  return (TRUE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %esi, %esi
js 0x26e9
leaq 0xb3b5(%rip), %rax      # 0xda40
testb $0x1, (%rax)
jne 0x26a0
xorl %edi, %edi
callq 0x622a
leaq 0xb48a(%rip), %rcx      # 0xdb28
movl %eax, (%rcx)
leaq 0xb3c1(%rip), %rax      # 0xda68
orb $0x1, (%rax)
leaq 0xb397(%rip), %rax      # 0xda48
movq (%rax), %r14
movq 0x18(%r14), %rcx
leaq 0xb379(%rip), %rax      # 0xda38
movq (%rax), %rax
incl %ebx
movq %rcx, %rdi
decl %ebx
je 0x26d5
movq 0x8(%rdi), %rcx
cmpq 0x28(%rax), %rcx
jne 0x26c4
movq %rdi, 0x18(%r14)
callq 0x238c
movq %rax, 0x20(%r14)
orb $0x2, 0x3b(%r14)
jmp 0x26f2
negl %ebx
movl %ebx, %esi
callq 0x259a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/basic.c
// Function: forwpage
int forwpage (int f, int n)
{
  LINE *lp;

  if (f == FALSE)
    {
      n = curwp->w_ntrows - 2;	 /* Default scroll */
      if (n <= 0)		 /* Forget the overlap */
	n = 1;			 /* if tiny window */
    }
  else if (n < 0)
    return (backpage (f, -n));
  else			       /* Convert from pages */
    n *= curwp->w_ntrows;      /* to lines */
  lp = curwp->w_linep;
  while (n-- && lp != curbp->b_linep)
    lp = lforw (lp);
  curwp->w_linep = lp;
  curwp->w_dotp = lp;
  curwp->w_doto = 0;
  curwp->w_flag |= WFHARD;
  return (TRUE);
}

// Assembly:
pushq %rax
testl %edi, %edi
je 0x271b
testl %esi, %esi
js 0x2776
leaq 0xb339(%rip), %rax      # 0xda48
movq (%rax), %rax
movsbl 0x39(%rax), %eax
imull %esi, %eax
jmp 0x2739
leaq 0xb326(%rip), %rax      # 0xda48
movq (%rax), %rax
movzbl 0x39(%rax), %eax
cmpb $0x4, %al
movl $0x3, %ecx
cmovgel %eax, %ecx
movzbl %cl, %eax
addl $-0x2, %eax
leaq 0xb308(%rip), %rcx      # 0xda48
movq (%rcx), %rcx
leaq 0x10(%rcx), %rdx
leaq 0xb2ea(%rip), %rsi      # 0xda38
movq (%rsi), %rsi
incl %eax
movq (%rdx), %rdx
decl %eax
je 0x2760
cmpq 0x28(%rsi), %rdx
jne 0x2753
movq %rdx, 0x10(%rcx)
movq %rdx, 0x18(%rcx)
movq $0x0, 0x20(%rcx)
orb $0x8, 0x3b(%rcx)
jmp 0x277d
negl %esi
callq 0x2784
movl $0x1, %eax
popq %rcx
retq