LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x37b9(%rip), %rdi      # 0x9bf9
callq 0x6334
testb %al, %al
je 0x645e
orb $0x22, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6468
andb $-0x23, 0x18(%rbx)
jmp 0x6460
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3701(%rip), %rdi      # 0x9bf9
callq 0x63a2
testb %al, %al
je 0x6516
orb $0x24, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6468
andb $-0x25, 0x18(%rbx)
jmp 0x6518
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x35aa(%rip), %rsi      # 0x9c1d
leaq 0x352c(%rip), %rdx      # 0x9ba6
movl $0x80010000, %edi       # imm = 0x80010000
movl $0x1b0, %ecx            # imm = 0x1B0
callq 0x31c0
movq 0x7e50(%rip), %rax      # 0xe4e0
cmpq $0x60906090, %rax       # imm = 0x60906090
je 0x66b9
leaq 0x352f(%rip), %rsi      # 0x9bce
leaq 0x3500(%rip), %rdx      # 0x9ba6
movl $0x80020000, %edi       # imm = 0x80020000
movl $0x11a, %ecx            # imm = 0x11A
callq 0x31c0
testb %al, %al
je 0x6723
leaq 0x355d(%rip), %rsi      # 0x9c1d
leaq 0x34df(%rip), %rdx      # 0x9ba6
movq %r14, %rdi
movl $0x1b2, %ecx            # imm = 0x1B2
callq 0x54c9
testb %al, %al
je 0x6723
leaq 0x7e09(%rip), %rdi      # 0xe4e8
callq 0x7790
testb %al, %al
je 0x6706
leaq 0x7e21(%rip), %rdi      # 0xe510
movq %r14, %rsi
callq *%rbx
movl %eax, %ebx
leaq 0x7deb(%rip), %rdi      # 0xe4e8
callq 0x782e
movl %ebx, %eax
jmp 0x6725
leaq 0x3510(%rip), %rsi      # 0x9c1d
leaq 0x3492(%rip), %rdx      # 0x9ba6
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_O3/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 0x74b2(%rip), %rcx      # 0xe440
movzwl 0x30(%rcx), %r9d
cmpw %di, %r9w
jne 0x6f9f
addq $0x30, %rcx
jmp 0x7001
movl $0x7, %r8d
movl $0x3, %edx
xorl %esi, %esi
leaq 0x23d4(%rip), %rax      # 0x9387
cmpq %r8, %rsi
je 0x7005
cmpw %di, %r9w
setb %r9b
leaq -0x1(%rdx), %r10
cmpq %rsi, %r10
setb %r11b
orb %r9b, %r11b
cmpb $0x1, %r11b
jne 0x6fe2
cmpq %r8, %rdx
jae 0x7005
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 0x6fb3
addq %r11, %rcx
movq 0x8(%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x77ba
callq 0x2470
testl %eax, %eax
je 0x77db
leaq 0x2636(%rip), %rsi      # 0x9ddc
leaq 0x2624(%rip), %rdx      # 0x9dd1
movl %eax, %edi
movl $0x3c, %ecx
popq %rax
jmp 0x32bc
leaq 0x261b(%rip), %rsi      # 0x9ddc
leaq 0x2609(%rip), %rdx      # 0x9dd1
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x3a, %ecx
callq 0x31c0
xorl %eax, %eax
jmp 0x77dd
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7809
callq 0x21e0
testl %eax, %eax
je 0x782a
leaq 0x25f6(%rip), %rsi      # 0x9deb
leaq 0x25d5(%rip), %rdx      # 0x9dd1
movl %eax, %edi
movl $0x45, %ecx
popq %rax
jmp 0x32bc
leaq 0x25db(%rip), %rsi      # 0x9deb
leaq 0x25ba(%rip), %rdx      # 0x9dd1
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x43, %ecx
callq 0x31c0
xorl %eax, %eax
jmp 0x782c
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7858
callq 0x22f0
testl %eax, %eax
je 0x7879
leaq 0x25b9(%rip), %rsi      # 0x9dfd
leaq 0x2586(%rip), %rdx      # 0x9dd1
movl %eax, %edi
movl $0x4e, %ecx
popq %rax
jmp 0x32bc
leaq 0x259e(%rip), %rsi      # 0x9dfd
leaq 0x256b(%rip), %rdx      # 0x9dd1
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x4c, %ecx
callq 0x31c0
xorl %eax, %eax
jmp 0x787b
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x78a7
callq 0x2160
testl %eax, %eax
je 0x78c8
leaq 0x257b(%rip), %rsi      # 0x9e0e
leaq 0x2537(%rip), %rdx      # 0x9dd1
movl %eax, %edi
movl $0x57, %ecx
popq %rax
jmp 0x32bc
leaq 0x2560(%rip), %rsi      # 0x9e0e
leaq 0x251c(%rip), %rdx      # 0x9dd1
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x55, %ecx
callq 0x31c0
xorl %eax, %eax
jmp 0x78ca
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2542(%rip), %rsi      # 0x9e20
leaq 0x254c(%rip), %rdx      # 0x9e31
movl $0x80010000, %edi       # imm = 0x80010000
movl $0x25, %ecx
callq 0x31c0
xorl %ebp, %ebp
callq 0x62a2
testb %al, %al
je 0x7a0e
testq %rbx, %rbx
je 0x797c
cmpb $0x0, (%rbx)
je 0x797c
movl $0x1, %edi
movl $0x68, %esi
callq 0x2220
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x799b
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x2240
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x79dd
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)
testq %rax, %rax
je 0x79b7
cmpb $0x0, (%rax)
je 0x79b7
movq %r14, %rdi
callq 0x7a5e
movl %eax, %ebp
jmp 0x7a0e
leaq 0x249d(%rip), %rsi      # 0x9e20
leaq 0x24a7(%rip), %rdx      # 0x9e31
movl $0x800a0000, %edi       # imm = 0x800A0000
movl $0x27, %ecx
callq 0x31c0
jmp 0x7a0e
callq 0x2080
movl (%rax), %edi
leaq 0x2477(%rip), %rsi      # 0x9e20
leaq 0x2481(%rip), %rdx      # 0x9e31
movl $0x2c, %ecx
jmp 0x7a06
leaq 0x8(%rsp), %rdi
callq 0x7a19
callq 0x2080
movl (%rax), %edi
leaq 0x2451(%rip), %rsi      # 0x9e20
leaq 0x245b(%rip), %rdx      # 0x9e31
movl $0x47, %ecx
jmp 0x7a06
callq 0x2050
leaq 0x8(%rsp), %rdi
callq 0x7a19
callq 0x2080
movl (%rax), %edi
leaq 0x2426(%rip), %rsi      # 0x9e20
leaq 0x2430(%rip), %rdx      # 0x9e31
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_O3/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 0x2057(%rip), %rsi      # 0x9ece
leaq 0x1fb3(%rip), %rdx      # 0x9e31
movl $0x80010000, %edi       # imm = 0x80010000
movl $0x132, %ecx            # imm = 0x132
callq 0x31c0
callq 0x62a2
testb %al, %al
je 0x7edc
movl $0x2, %edi
callq 0x5f5f
testq %rax, %rax
je 0x7ebf
movq %rax, %rdi
movl %ebx, %esi
callq 0x7ee0
movl %eax, %ebx
movl $0x2, %edi
callq 0x60fa
movl %ebx, %eax
jmp 0x7ede
leaq 0x2008(%rip), %rsi      # 0x9ece
leaq 0x1f64(%rip), %rdx      # 0x9e31
movl $0x800f0000, %edi       # imm = 0x800F0000
movl $0x137, %ecx            # imm = 0x137
callq 0x31c0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7fca
movq 0x80(%rdi), %rcx
testq %rcx, %rcx
je 0x7fe7
xorl %edx, %edx
movq (%rdi,%rdx,8), %rax
cmpl %esi, 0x60(%rax)
je 0x7fe9
incq %rdx
cmpq %rdx, %rcx
jne 0x7fb7
jmp 0x7fe7
leaq 0x1f37(%rip), %rsi      # 0x9f08
leaq 0x1e59(%rip), %rdx      # 0x9e31
movl $0x800b0000, %edi       # imm = 0x800B0000
movl $0x184, %ecx            # imm = 0x184
callq 0x31c0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x80b7
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x80a6
leaq (%rbx,%rax,8), %r14
addq $-0x8, %r14
movq %r14, %rdi
callq 0x7a19
movq $0x0, (%r14)
movq 0x80(%rbx), %rax
decq %rax
movq %rax, 0x80(%rbx)
jne 0x807c
movl $0x88, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x21b0
jmp 0x80d4
leaq 0x1e77(%rip), %rsi      # 0x9f35
leaq 0x1d6c(%rip), %rdx      # 0x9e31
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_O3/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 0x5f5f
testq %rax, %rax
je 0x825b
movq (%rax), %rax
movzwl 0xb4(%rax), %edi
cmpw %bp, %di
jne 0x827c
addq $0xb4, %rax
jmp 0x82cb
leaq 0x1d8a(%rip), %rsi      # 0x9fec
leaq 0x1d95(%rip), %rdx      # 0x9ffe
movl $0x800f0000, %edi       # imm = 0x800F0000
movl $0x33, %ecx
callq 0x31c0
xorl %ebx, %ebx
jmp 0x82dc
movl $0x7, %esi
movl $0x3, %ecx
xorl %edx, %edx
leaq 0x10f8(%rip), %rbx      # 0x9387
cmpq %rsi, %rdx
je 0x82d2
cmpw %bp, %di
jb 0x82a2
leaq -0x1(%rcx), %r8
cmpq %rdx, %r8
jae 0x82b0
cmpq %rsi, %rcx
jae 0x82d2
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 0x828f
addq %r9, %rax
movq %rax, %rbx
addq $0x10, %rbx
movl $0x3, %edi
callq 0x60fa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1d18(%rip), %rsi      # 0xa00d
leaq 0x1d02(%rip), %rdx      # 0x9ffe
movl $0x80010000, %edi       # imm = 0x80010000
movl $0x46, %ecx
callq 0x31c0
callq 0x62a2
testb %al, %al
je 0x837e
movzwl %bp, %edi
leaq 0x1cef(%rip), %rsi      # 0xa00d
leaq 0x1cd9(%rip), %rdx      # 0x9ffe
movl $0x48, %ecx
callq 0x5630
testb %al, %al
je 0x837e
movl $0x3, %edi
callq 0x5f5f
testq %rax, %rax
je 0x8361
movq (%rax), %rcx
movzwl 0xb4(%rcx), %r8d
cmpw %bp, %r8w
jne 0x8389
addq $0xb4, %rcx
movl $0x3, %edx
jmp 0x83d3
leaq 0x1ca5(%rip), %rsi      # 0xa00d
leaq 0x1c8f(%rip), %rdx      # 0x9ffe
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 0x8401
cmpw %bp, %r8w
jb 0x83a9
leaq -0x1(%rdx), %r9
cmpq %rsi, %r9
jae 0x83b7
cmpq %rdi, %rdx
jae 0x8401
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 0x8395
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 0x8412
movl %eax, %ebx
jmp 0x8403
xorl %ebx, %ebx
movl $0x3, %edi
callq 0x60fa
jmp 0x8380
// File: /workspace/github_c_makefile_star2_O3/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 0x863f
decl %edi
cmpl $0x7, %edi
ja 0x866b
leaq 0x193e(%rip), %rax      # 0x9f6c
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x194e(%rip), %rax      # 0x9f8c
retq
cmpl $0x3f, %edi
jg 0x8656
cmpl $0x10, %edi
je 0x868b
cmpl $0x20, %edi
jne 0x866b
leaq 0x1973(%rip), %rax      # 0x9fc8
retq
cmpl $0x40, %edi
je 0x866b
cmpl $0x80, %edi
jne 0x866b
leaq 0x1976(%rip), %rax      # 0x9fe0
retq
leaq 0x1962(%rip), %rax      # 0x9fd4
retq
leaq 0x1936(%rip), %rax      # 0x9fb0
retq
leaq 0x1916(%rip), %rax      # 0x9f98
retq
leaq 0x191a(%rip), %rax      # 0x9fa4
retq
leaq 0x192a(%rip), %rax      # 0x9fbc
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x197d(%rip), %rsi      # 0xa01f
leaq 0x1955(%rip), %rdx      # 0x9ffe
movl $0x80010000, %edi       # imm = 0x80010000
movl $0x74, %ecx
callq 0x31c0
callq 0x62a2
testb %al, %al
je 0x874e
movl $0x3, %edi
callq 0x5f5f
testq %rax, %rax
je 0x8731
movq %rax, %r14
movb $0x1, %bl
movl $0x10, %r15d
movq (%r14), %r12
movzwl -0x10(%r12,%r15), %edi
callq 0x861b
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 0x8412
andb %al, %bl
addq $0x3c, %r15
cmpq $0x1f0, %r15            # imm = 0x1F0
jne 0x86df
movl $0x3, %edi
callq 0x60fa
jmp 0x8750
leaq 0x18e7(%rip), %rsi      # 0xa01f
leaq 0x18bf(%rip), %rdx      # 0x9ffe
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_O3/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 0x17e2(%rip), %rsi      # 0xa08f
leaq 0x174a(%rip), %rdx      # 0x9ffe
movl $0xc4, %ecx
callq 0x56ea
testb %al, %al
je 0x891b
movl $0x3, %edi
callq 0x5f5f
testq %rax, %rax
je 0x88f2
movq 0x8(%rax), %rax
cmpl %ebx, (%rax)
je 0x88e4
movl %ebx, (%rax)
callq 0x8693
testb %al, %al
je 0x8911
movl $0x3, %edi
callq 0x60fa
movb $0x1, %al
jmp 0x891d
leaq 0x1796(%rip), %rsi      # 0xa08f
leaq 0x16fe(%rip), %rdx      # 0x9ffe
movl $0x800f0000, %edi       # imm = 0x800F0000
movl $0xc7, %ecx
callq 0x31c0
jmp 0x891b
movl $0x3, %edi
callq 0x60fa
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x30d0(%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 0x1d04
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3278
addl %r14d, %ebx
cmpl %ebp, %ebx
jl 0x315c
subl 0x10(%rsp), %ebx
movl 0x4(%rsp), %ebp
cmpl %ebp, %ebx
jge 0x31a4
movq %r13, %rdi
movl %ebx, %esi
callq 0x1d04
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3278
addl %r14d, %ebx
jmp 0x3183
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 0x31cc
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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), %r13
movl $0x3e8, %edi            # imm = 0x3E8
movl $0x7d0, %esi            # imm = 0x7D0
movq %r14, %rdx
movq %r13, %rcx
callq 0x11cc
movq (%r14), %r15
leaq 0x4(%r15), %r12
movq (%r13), %r14
leaq 0x4(%r14), %r13
xorl %edi, %edi
callq 0x1090
movl $0x1, %edi
callq 0x10a0
movq %rax, %rbp
callq 0x1030
movq %rbp, (%rsp)
movl $0x3e8, %esi            # imm = 0x3E8
movl $0x7d0, %ecx            # imm = 0x7D0
movl $0x7d0, %r9d            # imm = 0x7D0
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %r8
callq 0x10c0
callq 0x1040
movq %rax, %rbp
callq 0x1050
leaq 0xcf8(%rip), %rdi       # 0x2010
movb $0x1, %al
callq *%rbp
movl $0x1, %edi
callq 0x1090
movl $0x1, %edi
callq 0x10a0
movq %rax, %rbp
callq 0x1030
movq %rbp, (%rsp)
movl $0x3e8, %esi            # imm = 0x3E8
movl $0x7d0, %ecx            # imm = 0x7D0
movl $0x7d0, %r9d            # imm = 0x7D0
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %r8
callq 0x10c0
callq 0x1040
movq %rax, %r12
callq 0x1050
leaq 0xcbd(%rip), %rdi       # 0x202b
movb $0x1, %al
callq *%r12
movq %r15, %rdi
callq 0x1070
movq %r14, %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_O3/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 0x276d
leaq 0xb339(%rip), %rax      # 0xda48
movq (%rax), %rax
movsbl 0x39(%rax), %ecx
imull %esi, %ecx
jmp 0x273a
leaq 0xb326(%rip), %rax      # 0xda48
movq (%rax), %rax
movzbl 0x39(%rax), %ecx
cmpb $0x4, %cl
movl $0x3, %edx
cmovgel %ecx, %edx
movzbl %dl, %ecx
addl $-0x2, %ecx
leaq 0x10(%rax), %rdx
leaq 0xb2f3(%rip), %rsi      # 0xda38
movq (%rsi), %rsi
incl %ecx
movq (%rdx), %rdx
decl %ecx
je 0x2757
cmpq 0x28(%rsi), %rdx
jne 0x274a
movq %rdx, 0x10(%rax)
movq %rdx, 0x18(%rax)
movq $0x0, 0x20(%rax)
orb $0x8, 0x3b(%rax)
jmp 0x2774
negl %esi
callq 0x277b
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/basic.c
// Function: backpage
int backpage (int f, int n)
{
  LINE *lp;

  if (f == FALSE)
    {
      n = curwp->w_ntrows - 2;	 /* Default scroll */
      if (n <= 0)		 /* Don't blow up if the window is tiny */
	n = 1;
    }
  else if (n < 0)
    return (forwpage (f, -n));
  else			       /* Convert from pages to lines */
    n *= curwp->w_ntrows;
  lp = curwp->w_linep;
  while (n-- && lback (lp) != curbp->b_linep)
    lp = lback (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 0x2797
testl %esi, %esi
js 0x27ed
leaq 0xb2bd(%rip), %rax      # 0xda48
movq (%rax), %rax
movsbl 0x39(%rax), %ecx
imull %esi, %ecx
jmp 0x27b6
leaq 0xb2aa(%rip), %rax      # 0xda48
movq (%rax), %rax
movzbl 0x39(%rax), %ecx
cmpb $0x4, %cl
movl $0x3, %edx
cmovgel %ecx, %edx
movzbl %dl, %ecx
addl $-0x2, %ecx
movq 0x10(%rax), %rdi
leaq 0xb277(%rip), %rdx      # 0xda38
movq (%rdx), %rdx
incl %ecx
movq %rdi, %rsi
decl %ecx
je 0x27d7
movq 0x8(%rsi), %rdi
cmpq 0x28(%rdx), %rdi
jne 0x27c6
movq %rsi, 0x10(%rax)
movq %rsi, 0x18(%rax)
movq $0x0, 0x20(%rax)
orb $0x8, 0x3b(%rax)
jmp 0x27f4
negl %esi
callq 0x26ff
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/buffer.c
// Function: swbuffer
int swbuffer (BUFFER *bp)
{
  WINDOW *wp;

  if (--curbp->b_nwnd == 0)
    {				/* Last use. */
      curbp->b_dotp = curwp->w_dotp;
      curbp->b_doto = curwp->w_doto;
      curbp->b_markp = curwp->w_markp;
      curbp->b_marko = curwp->w_marko;
    }
  curbp = bp;			/* Switch. */
  if (curbp->b_active != TRUE)
    {				/* buffer not active yet */
      /* read it in and activate it */
      readin (curbp->b_fname);
      curbp->b_dotp = lforw (curbp->b_linep);
      curbp->b_doto = 0;
      curbp->b_active = TRUE;
    }
  curwp->w_bufp = bp;
  curwp->w_linep = bp->b_linep;	/* For macros, ignored */
  curwp->w_flag |= WFMODE | WFFORCE | WFHARD; /* Quite nasty */
  if (bp->b_nwnd++ == 0)
    {				/* First use */
      curwp->w_dotp = bp->b_dotp;
      curwp->w_doto = bp->b_doto;
      curwp->w_markp = bp->b_markp;
      curwp->w_marko = bp->b_marko;
      return (TRUE);
    }
  wp = wheadp;			/* Look for old */
  while (wp != 0)
    {
      if (wp != curwp && wp->w_bufp == bp)
	{
	  curwp->w_dotp = wp->w_dotp;
	  curwp->w_doto = wp->w_doto;
	  curwp->w_markp = wp->w_markp;
	  curwp->w_marko = wp->w_marko;
	  break;
	}
      wp = wp->w_wndp;
    }
  return (TRUE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb1e5(%rip), %r14      # 0xda38
movq (%r14), %rax
decb 0x31(%rax)
jne 0x2885
leaq 0xb1e6(%rip), %rcx      # 0xda48
movq (%rcx), %rcx
movq 0x18(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x20(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq %rbx, (%r14)
cmpb $0x1, 0x30(%rbx)
je 0x28b1
leaq 0x33(%rbx), %rdi
callq 0x49c2
movq (%r14), %rax
movq 0x28(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb $0x1, 0x30(%rax)
leaq 0xb190(%rip), %rax      # 0xda48
movq (%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x28(%rbx), %rcx
movq %rcx, 0x10(%rax)
orb $0x19, 0x3b(%rax)
movb 0x31(%rbx), %cl
leal 0x1(%rcx), %edx
movb %dl, 0x31(%rbx)
testb %cl, %cl
je 0x2913
leaq 0xb181(%rip), %rcx      # 0xda60
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x2936
cmpq %rax, %rcx
je 0x28df
cmpq %rbx, 0x8(%rcx)
jne 0x28df
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x20(%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x28(%rax)
addq $0x30, %rcx
movq %rcx, %rbx
jmp 0x292f
movq 0x8(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x28(%rax)
addq $0x20, %rbx
movq (%rbx), %rcx
movq %rcx, 0x30(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/buffer.c
// Function: killbuffer
int killbuffer (int f, int n)
{
  BUFFER *bp;
  BUFFER *bp_alt;
  char bufn[NBUFN];
  char prompt[NFILEN];
  int s;

  sprintf(prompt, "Kill Buffer: (default %s) ", curbp->b_bname);
  s = mlreply (prompt, bufn, NBUFN);

  if (s == ABORT)
	return ABORT;
  else if (s == FALSE) {
	bp = curbp;
  } else {
	/* return if cant find named buffer */
	if ((bp = bfind (bufn, FALSE, 0)) == NULL)
	  return FALSE;
  }

  /* beep if attempt to kill buffer list */
  if (bp == blistp) {
	(*term.t_beep) ();
	mlerase();
	return FALSE;
  }

  /* find a buffer to switch to, not this one and not an internal buffer */
  bp_alt = bheadp;
  while (bp_alt != NULL)
	{
	  if (bp_alt != bp && (bp_alt->b_flag & BFTEMP) != BFTEMP)
		break;
	  bp_alt = bp_alt->b_bufp;
	}

  /* no alternate buffer, try for scratch or create it */
  if (bp_alt == NULL) {
	bp_alt = get_scratch();
  }

  if (bp_alt == NULL) {
	  return (FALSE);
  }

  swbuffer(bp_alt);
  s = zotbuf(bp);
  mlerase();
  return s;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq 0xb0b4(%rip), %r14      # 0xda38
movl $0x83, %edx
addq (%r14), %rdx
leaq 0x668e(%rip), %rsi      # 0x9021
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2250
movq %rsp, %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x4705
movl %eax, %ebp
cmpl $0x2, %eax
je 0x2a33
testl %ebp, %ebp
jne 0x29c2
movq (%r14), %rbx
jmp 0x29d8
movq %rsp, %rdi
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x2a42
movq %rax, %rbx
testq %rax, %rax
je 0x2a33
leaq 0xb079(%rip), %rax      # 0xda58
cmpq (%rax), %rbx
je 0x2a1e
leaq 0xb145(%rip), %rax      # 0xdb30
movq (%rax), %rax
testq %rax, %rax
je 0x2a00
cmpq %rbx, %rax
je 0x29eb
testb $0x1, 0x32(%rax)
jne 0x29eb
jmp 0x2a0a
callq 0x2b5b
testq %rax, %rax
je 0x2a3e
movq %rax, %rdi
callq 0x2845
movq %rbx, %rdi
callq 0x2b87
movl %eax, %ebp
jmp 0x2a2c
leaq 0xae43(%rip), %rcx      # 0xd868
xorl %ebp, %ebp
xorl %eax, %eax
callq *0x50(%rcx)
xorl %eax, %eax
callq 0x3384
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x2a33
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/buffer.c
// Function: bfind
BUFFER* bfind (char *bname, int cflag, int bflag)
{
  BUFFER *bp, *sb;
  LINE *lp;

  bp = bheadp;
  while (bp != 0)
    {
      if (strcmp (bname, bp->b_bname) == 0)
	{
	  if ((bp->b_flag & BFTEMP) != 0)
	    {
	      mlwrite ("Cannot select builtin buffer");
	      return (0);
	    }
	  return (bp);
	}
      bp = bp->b_bufp;
    }
  if (cflag != FALSE)
    {
      if ((bp = (BUFFER *) malloc (sizeof (BUFFER))) == NULL)
	return (0);
      if ((lp = lalloc (0)) == NULL)
	{
	  free (bp);
	  return (BUFFER*)0;
	}
      /* find the place in the list to insert this buffer */
      if (bheadp == NULL || strcmp (bheadp->b_bname, bname) > 0)
	{
	  /* insert at the begining */
	  bp->b_bufp = bheadp;
	  bheadp = bp;
	}
      else
	{
	  sb = bheadp;
	  while (sb->b_bufp != 0)
	    {
	      if (strcmp (sb->b_bufp->b_bname, bname) > 0)
		break;
	      sb = sb->b_bufp;
	    }

	  /* and insert it */
	  bp->b_bufp = sb->b_bufp;
	  sb->b_bufp = bp;
	}

      /* and set up the other buffer fields */
      bp->b_active = TRUE;
      bp->b_dotp = lp;
      bp->b_doto = 0;
      bp->b_markp = 0;
      bp->b_marko = 0;
      bp->b_flag = (char)bflag;
      bp->b_nwnd = 0;
      bp->b_linep = lp;
      strncpy (bp->b_fname, "", 1);
      strncpy (bp->b_bname, bname, NBUFN);
      lp->l_fp = lp;
      lp->l_bp = lp;
    }
  return (bp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
leaq 0xb0d4(%rip), %rbx      # 0xdb30
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2a96
leaq 0x83(%rbx), %rsi
movq %r14, %rdi
callq 0x2170
testl %eax, %eax
jne 0x2a5c
testb $0x1, 0x32(%rbx)
je 0x2b49
leaq 0x6602(%rip), %rdi      # 0x908a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4246
jmp 0x2b49
testl %r15d, %r15d
je 0x2b47
movl $0x98, %edi
callq 0x21a0
testq %rax, %rax
je 0x2b47
movq %rax, %rbx
xorl %edi, %edi
xorl %eax, %eax
callq 0x4ef4
testq %rax, %rax
je 0x2b3f
movq %rax, %r15
leaq 0xb063(%rip), %r13      # 0xdb30
movq (%r13), %r12
testq %r12, %r12
je 0x2af3
leaq 0x83(%r12), %rdi
movq %r14, %rsi
callq 0x2170
testl %eax, %eax
jg 0x2af3
movq %r12, %r13
movq (%r12), %r12
jmp 0x2ad1
movq %r12, (%rbx)
movq %rbx, (%r13)
movw $0x1, 0x30(%rbx)
movq %r15, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movb %bpl, 0x32(%rbx)
movq %r15, 0x28(%rbx)
movb $0x0, 0x33(%rbx)
movq %rbx, %rdi
addq $0x83, %rdi
movl $0x10, %edx
movq %r14, %rsi
callq 0x2070
movq %r15, (%r15)
movq %r15, 0x8(%r15)
jmp 0x2b49
movq %rbx, %rdi
callq 0x2040
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/buffer.c
// Function: zotbuf
int zotbuf (BUFFER *bp)
{
  BUFFER *bp1, *bp2;
  int s;

  /* we ony get here if there is only *scratch* left */
  if (bp->b_nwnd != 0)
	return (FALSE); /* fail silently */
  if ((s = bclear (bp)) != TRUE) /* Blow text away */
    return (s);
  free (bp->b_linep);		/* Release header line */
  bp1 = 0;			/* Find the header */
  bp2 = bheadp;
  while (bp2 != bp)
    {
      bp1 = bp2;
      bp2 = bp2->b_bufp;
    }
  bp2 = bp2->b_bufp;		/* Next one in chain */
  if (bp1 == NULL)		/* Unlink it */
    bheadp = bp2;
  else
    bp1->b_bufp = bp2;
  free (bp);			/* Release buffer block */
  return (TRUE);
}

// Assembly:
xorl %eax, %eax
cmpb $0x0, 0x31(%rdi)
je 0x2b90
retq
pushq %rbx
movq %rdi, %rbx
callq 0x2bdf
cmpl $0x1, %eax
jne 0x2bdd
movq 0x28(%rbx), %rdi
callq 0x2040
leaq 0xaf82(%rip), %rdx      # 0xdb30
xorl %ecx, %ecx
movq %rcx, %rax
movq (%rdx), %rcx
movq %rcx, %rdx
cmpq %rbx, %rcx
jne 0x2bb0
movq (%rcx), %rcx
testq %rax, %rax
jne 0x2bcd
leaq 0xaf63(%rip), %rax      # 0xdb30
movq %rcx, (%rax)
movq %rbx, %rdi
callq 0x2040
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/buffer.c
// Function: bclear
int bclear (BUFFER *bp)
{
  LINE *lp;
  int s;

  if ((bp->b_flag & BFTEMP) == 0 /* Not scratch buffer */
      && (bp->b_flag & BFCHG) != 0 /* Something changed */
      && (s = mlyesno ("Discard changes")) != TRUE)
    return (s);
  bp->b_flag &= ~BFCHG;		/* Not changed */
  while ((lp = lforw (bp->b_linep)) != bp->b_linep)
    lfree (lp);
  bp->b_dotp = bp->b_linep;	/* Fix "." */
  bp->b_doto = 0;
  bp->b_markp = 0;		/* Invalidate "mark" */
  bp->b_marko = 0;
  return (TRUE);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb 0x32(%rdi), %al
movl %eax, %ecx
andb $0x3, %cl
cmpb $0x2, %cl
jne 0x2c04
leaq 0x64b0(%rip), %rdi      # 0x90a7
callq 0x41be
cmpl $0x1, %eax
jne 0x2c34
movb 0x32(%rbx), %al
andb $-0x3, %al
movb %al, 0x32(%rbx)
movq 0x28(%rbx), %rax
movq (%rax), %rdi
cmpq %rax, %rdi
je 0x2c1c
callq 0x4f42
jmp 0x2c09
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/buffer.c
// Function: listbuffers
int listbuffers (int f, int n)
{
  WINDOW *wp;
  BUFFER *bp;
  int s;

  if ((s = makelist ()) != TRUE)
    return (s);
  if (blistp->b_nwnd == 0)
    {				/* Not on screen yet */
      if ((wp = wpopup ()) == NULL)
	return (FALSE);
      bp = wp->w_bufp;
      if (--bp->b_nwnd == 0)
	{
	  bp->b_dotp = wp->w_dotp;
	  bp->b_doto = wp->w_doto;
	  bp->b_markp = wp->w_markp;
	  bp->b_marko = wp->w_marko;
	}
      wp->w_bufp = blistp;
      ++blistp->b_nwnd;
    }
  wp = wheadp;
  while (wp != 0)
    {
      if (wp->w_bufp == blistp)
	{
	  wp->w_linep = lforw (blistp->b_linep);
	  wp->w_dotp = lforw (blistp->b_linep);
	  wp->w_doto = 0;
	  wp->w_markp = 0;
	  wp->w_marko = 0;
	  wp->w_flag |= WFMODE | WFHARD;
	}
      wp = wp->w_wndp;
    }
  return (TRUE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x2ce9
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x2cdf
leaq 0xae07(%rip), %r14      # 0xda58
movq (%r14), %rcx
cmpb $0x0, 0x31(%rcx)
jne 0x2c9b
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x7fb6
testq %rax, %rax
je 0x2cdf
movq 0x8(%rax), %rcx
decb 0x31(%rcx)
jne 0x2c91
movq 0x18(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq 0x20(%rax), %rdx
movq %rdx, 0x10(%rcx)
movq 0x28(%rax), %rdx
movq %rdx, 0x18(%rcx)
movq 0x30(%rax), %rdx
movq %rdx, 0x20(%rcx)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
incb 0x31(%rcx)
leaq 0xadbe(%rip), %rax      # 0xda60
movq (%rax), %rax
movl $0x1, %ebx
testq %rax, %rax
je 0x2cdf
xorps %xmm0, %xmm0
cmpq %rcx, 0x8(%rax)
jne 0x2cd7
movq 0x28(%rcx), %rdx
movq (%rdx), %rdx
movq %rdx, 0x10(%rax)
movq %rdx, 0x18(%rax)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
orb $0x18, 0x3b(%rax)
movq (%rax), %rax
testq %rax, %rax
jne 0x2cb2
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/buffer.c
// Function: addline
int addline (char *text)
{
  LINE *lp;
  int ntext, i;

  ntext = strlen (text);
  if ((lp = lalloc (ntext)) == NULL)
    return (FALSE);
  for (i = 0; i < ntext; ++i)
    lputc (lp, i, text[i]);
  blistp->b_linep->l_bp->l_fp = lp; /* Hook onto the end */
  lp->l_bp = blistp->b_linep->l_bp;
  blistp->b_linep->l_bp = lp;
  lp->l_fp = blistp->b_linep;
  if (blistp->b_dotp == blistp->b_linep) /* If "." is at the end */
    blistp->b_dotp = lp;	/* move it to new line */
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20d0
movq %rax, %r14
xorl %ebp, %ebp
movl %r14d, %edi
xorl %eax, %eax
callq 0x4ef4
testq %rax, %rax
je 0x2f3b
testl %r14d, %r14d
jle 0x2efa
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, 0x18(%rax,%rcx)
incq %rcx
cmpq %rcx, %r14
jne 0x2eeb
leaq 0xab57(%rip), %rcx      # 0xda58
movq (%rcx), %rdx
movq 0x28(%rdx), %rdx
movq 0x8(%rdx), %rdx
movq %rax, (%rdx)
movq (%rcx), %rdx
movq 0x28(%rdx), %rdx
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rax)
movq %rax, 0x8(%rdx)
movq %rdx, (%rax)
movq (%rcx), %rcx
movq 0x8(%rcx), %rdx
movl $0x1, %ebp
cmpq 0x28(%rcx), %rdx
jne 0x2f3b
movq %rax, 0x8(%rcx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/buffer.c
// Function: itoa
void itoa (char buf[], int width, int num)
{
  buf[width] = 0;		/* End of string */
  while (num >= 10)
    {				/* Conditional digits */
      buf[--width] = (char)((num % 10) + '0');
      num /= 10;
    }
  buf[--width] = (char)(num + '0'); /* Always 1 digit */
  while (width != 0)		    /* Pad with blanks */
    buf[--width] = ' ';
}

// Assembly:
movslq %esi, %rax
movb $0x0, (%rdi,%rax)
cmpl $0xa, %edx
jl 0x2f87
addq %rdi, %rax
decq %rax
movl $0xcccccccd, %r8d       # imm = 0xCCCCCCCD
movl %edx, %ecx
imulq %r8, %rcx
shrq $0x23, %rcx
leal (%rcx,%rcx), %r9d
leal (%r9,%r9,4), %r9d
movl %edx, %r10d
subl %r9d, %r10d
orb $0x30, %r10b
movb %r10b, (%rax)
decl %esi
decq %rax
cmpl $0x63, %edx
movl %ecx, %edx
ja 0x2f5a
jmp 0x2f89
movl %edx, %ecx
addb $0x30, %cl
movslq %esi, %rax
movb %cl, -0x1(%rdi,%rax)
decq %rax
testl %eax, %eax
je 0x2fb2
addl $-0x2, %esi
movslq %esi, %rcx
subq %rsi, %rcx
addq %rcx, %rdi
movl %eax, %edx
movl $0x20, %esi
jmp 0x2130
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/display.c
// Function: movecursor
void movecursor (int row, int col)
{
  if (row != ttrow || col != ttcol)
    {
      ttrow = row;
      ttcol = col;
      (*term.t_move) (row, col);
    }
}

// Assembly:
cmpl %edi, 0x9e02(%rip)      # 0xd160
jne 0x3369
cmpl %esi, 0x9dfe(%rip)      # 0xd164
jne 0x3369
retq
movl %edi, 0x9df1(%rip)      # 0xd160
movl %esi, 0x9def(%rip)      # 0xd164
leaq 0xa4ec(%rip), %rax      # 0xd868
movq 0x38(%rax), %rcx
xorl %eax, %eax
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/display.c
// Function: mlerase
void mlerase ()
{
  int i;

  movecursor (term.t_nrow, 0);
  if (eolexist == TRUE)
    (*term.t_eeol) ();
  else
    {
      for (i = 0; i < term.t_ncol - 1; i++)
	(*term.t_putchar) (' ');
      movecursor (term.t_nrow, 1);	  /* force the move! */
      movecursor (term.t_nrow, 0);
    }
  (*term.t_flush) ();
  mpresf = FALSE;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0xa4da(%rip), %rbx      # 0xd868
movl (%rbx), %edi
cmpl %edi, 0x9dca(%rip)      # 0xd160
jne 0x33a1
cmpl $0x0, 0x9dc5(%rip)      # 0xd164
je 0x33b8
movl %edi, 0x9db9(%rip)      # 0xd160
movl $0x0, 0x9db3(%rip)      # 0xd164
xorl %esi, %esi
xorl %eax, %eax
callq *0x38(%rbx)
leaq 0x9fb1(%rip), %rax      # 0xd370
cmpl $0x1, (%rax)
jne 0x33cb
xorl %eax, %eax
callq *0x40(%rbx)
jmp 0x3441
cmpl $0x2, 0x4(%rbx)
jl 0x33e8
xorl %ebp, %ebp
movl $0x20, %edi
xorl %eax, %eax
callq *0x28(%rbx)
incl %ebp
movl 0x4(%rbx), %eax
decl %eax
cmpl %eax, %ebp
jl 0x33d3
movl (%rbx), %edi
cmpl %edi, 0x9d70(%rip)      # 0xd160
jne 0x3414
cmpl $0x1, 0x9d6b(%rip)      # 0xd164
jne 0x3414
movl %edi, 0x9d5f(%rip)      # 0xd160
movl $0x0, 0x9d59(%rip)      # 0xd164
xorl %esi, %esi
xorl %eax, %eax
callq *0x38(%rbx)
jmp 0x3441
movl %edi, 0x9d46(%rip)      # 0xd160
movl $0x1, 0x9d40(%rip)      # 0xd164
movl $0x1, %esi
xorl %eax, %eax
callq *0x38(%rbx)
movl (%rbx), %edi
cmpl %edi, 0x9d2a(%rip)      # 0xd160
jne 0x33fb
cmpl $0x0, 0x9d25(%rip)      # 0xd164
jne 0x33fb
xorl %eax, %eax
callq *0x30(%rbx)
leaq 0xa5e7(%rip), %rax      # 0xda34
movl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/display.c
// Function: vtinit
void vtinit ()
{
  VIDEO *vp;
  //char *malloc ();
  int i;

  (*term.t_open) ();
  (*term.t_rev) (FALSE);
  vscreen = (VIDEO **) malloc (term.t_nrow * sizeof (VIDEO *));

  if (vscreen == NULL)
    exit (1);

  pscreen = (VIDEO **) malloc (term.t_nrow * sizeof (VIDEO *));

  if (pscreen == NULL)
    exit (1);

  for (i = 0; i < term.t_nrow; ++i)
    {
      vp = (VIDEO *) malloc (sizeof (VIDEO) + term.t_ncol);

      if (vp == NULL)
	exit (1);

      vp->v_flag = 0;
      vscreen[i] = vp;
      vp = (VIDEO *) malloc (sizeof (VIDEO) + term.t_ncol);

      if (vp == NULL)
	exit (1);

      vp->v_flag = 0;
      pscreen[i] = vp;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xa402(%rip), %r15      # 0xd868
xorl %eax, %eax
callq *0x10(%r15)
xorl %edi, %edi
xorl %eax, %eax
callq *0x58(%r15)
movslq (%r15), %r14
leaq (,%r14,8), %rbx
movq %rbx, %rdi
callq 0x21a0
movq %rax, 0xa472(%rip)      # 0xd900
testq %rax, %rax
je 0x34ff
movq %rbx, %rdi
callq 0x21a0
movq %rax, 0xa466(%rip)      # 0xd908
testq %rax, %rax
je 0x34ff
testl %r14d, %r14d
jle 0x34f9
movslq 0x4(%r15), %rbx
addq $0x4, %rbx
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x21a0
testq %rax, %rax
je 0x34ff
movw $0x0, (%rax)
movq 0xa430(%rip), %rcx      # 0xd900
movq %rax, (%rcx,%r15,8)
movq %rbx, %rdi
callq 0x21a0
testq %rax, %rax
je 0x34ff
movw $0x0, (%rax)
movq 0xa41b(%rip), %rcx      # 0xd908
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x34b7
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %edi
callq 0x2260