LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x4c62(%rip), %rdx      # 0x118ec
leaq 0x4c2f(%rip), %rcx      # 0x118c0
movl $0x4c, %r8d
callq 0xcac0
testb $0x1, %al
jne 0xcca2
jmp 0xccf7
movq 0x8(%rsp), %rdi
callq 0x2310
movl %eax, 0x4(%rsp)
xorl %eax, %eax
cmpl 0x4(%rsp), %eax
jne 0xccc2
movl $0x1, %eax
movl %eax, (%rsp)
jmp 0xcce6
movl 0x4(%rsp), %edi
leaq 0x4c1f(%rip), %rsi      # 0x118ec
leaq 0x4bec(%rip), %rdx      # 0x118c0
movl $0x4e, %ecx
callq 0x3c00
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
movl (%rsp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xccfc
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x4bd3(%rip), %rdx      # 0x118fd
leaq 0x4b8f(%rip), %rcx      # 0x118c0
movl $0x55, %r8d
callq 0xcac0
testb $0x1, %al
jne 0xcd42
jmp 0xcd97
movq 0x8(%rsp), %rdi
callq 0x2160
movl %eax, 0x4(%rsp)
xorl %eax, %eax
cmpl 0x4(%rsp), %eax
jne 0xcd62
movl $0x1, %eax
movl %eax, (%rsp)
jmp 0xcd86
movl 0x4(%rsp), %edi
leaq 0x4b90(%rip), %rsi      # 0x118fd
leaq 0x4b4c(%rip), %rdx      # 0x118c0
movl $0x57, %ecx
callq 0x3c00
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
movl (%rsp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xcd9c
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirplugins.c
// Function: sir_plugin_destroy
void _sir_plugin_destroy(sir_plugin** plugin) {
#if !defined(SIR_NO_PLUGINS)
    if (_sir_validptrptr(plugin) && _sir_validptr(*plugin)) {
        bool unloaded = _sir_plugin_unload(*plugin);
        SIR_ASSERT_UNUSED(unloaded, unloaded);

        _sir_safefree(&(*plugin)->path);
        _sir_safefree(plugin);
    }
#else
    SIR_UNUSED(plugin);
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x4daa(%rip), %rdx      # 0x11e34
leaq 0x488f(%rip), %rcx      # 0x11920
movl $0x144, %r8d            # imm = 0x144
callq 0xdee0
testb $0x1, %al
jne 0xd0a2
jmp 0xd0f8
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
leaq 0x4d7e(%rip), %rdx      # 0x11e34
leaq 0x4863(%rip), %rcx      # 0x11920
movl $0x144, %r8d            # imm = 0x144
callq 0xd900
testb $0x1, %al
jne 0xd0ce
jmp 0xd0f8
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0xd970
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x7910
movq 0x10(%rsp), %rdi
callq 0x7910
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirplugins.c
// Function: sir_plugin_getexport
sir_pluginexport _sir_plugin_getexport(sir_pluginhandle handle, const char* name) {
#if !defined(SIR_NO_PLUGINS)
    if (!_sir_validptr(handle) || !_sir_validstr(name))
        return NULL;

# if !defined(__WIN__)
    sir_pluginexport addr = NULL;
    *(void**)(&addr) = dlsym(handle, name);

    if (!addr) {
        const char* err = dlerror();
        _sir_selflog("error: dlsym(%p, '%s') failed (%s)", handle, name,
            _SIR_PRNSTR(err));
        (void)_sir_handleerr(errno);
        return NULL;
    }
# else /* __WIN__ */
    sir_pluginexport addr = GetProcAddress(handle, name);
    if (!addr) {
        DWORD err = GetLastError();
        _sir_selflog("error: GetProcAddress(%p, '%s') failed (%lu)", handle,
            name, err);
        (void)_sir_handlewin32err(err);
        return NULL;
    }
# endif
    _sir_selflog("successfully resolved plugin export (name: '%s', addr: %"
                 PRIxPTR")", name, (uintptr_t)addr);
    return addr;
#else
    SIR_UNUSED(handle);
    SIR_UNUSED(name);
    return NULL;
#endif
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x4610(%rip), %rdx      # 0x11cbf
leaq 0x426a(%rip), %rcx      # 0x11920
movl $0xd7, %r8d
callq 0xd900
testb $0x1, %al
jne 0xd6c7
jmp 0xd6ee
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x45e7(%rip), %rdx      # 0x11cbf
leaq 0x4241(%rip), %rcx      # 0x11920
movl $0xd7, %r8d
callq 0xcfe0
testb $0x1, %al
jne 0xd6fc
movq $0x0, 0x40(%rsp)
jmp 0xd7ce
movq $0x0, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x23b0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xd7ac
callq 0x2040
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xd757
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xd765
leaq 0x41ef(%rip), %rax      # 0x1194d
movq %rax, 0x8(%rsp)
jmp 0xd765
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rcx
leaq 0x455a(%rip), %rdi      # 0x11cd5
movb $0x0, %al
callq 0xd060
callq 0x2070
movl (%rax), %edi
leaq 0x452f(%rip), %rsi      # 0x11cbf
leaq 0x4189(%rip), %rdx      # 0x11920
movl $0xe2, %ecx
callq 0x3c00
movq $0x0, 0x40(%rsp)
jmp 0xd7ce
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x453b(%rip), %rdi      # 0x11cf8
movb $0x0, %al
callq 0xd060
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirplugins.c
// Function: sir_plugin_add
sirpluginid _sir_plugin_add(sir_plugin* plugin) {
#if !defined(SIR_NO_PLUGINS)
    sirpluginid retval = 0U;

    if (_sir_validptr(plugin)) {
        _SIR_LOCK_SECTION(sir_plugincache, spc, SIRMI_PLUGINCACHE, 0U);
        retval = _sir_plugin_cache_add(spc, plugin);
        _SIR_UNLOCK_SECTION(SIRMI_PLUGINCACHE);
    }

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x45a2(%rip), %rdx      # 0x11e14
leaq 0x40a7(%rip), %rcx      # 0x11920
movl $0x123, %r8d            # imm = 0x123
callq 0xd900
testb $0x1, %al
jne 0xd88a
jmp 0xd8e7
movl $0x2, %edi
callq 0x9650
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xd8c8
movl $0x800f0000, %edi       # imm = 0x800F0000
leaq 0x4567(%rip), %rsi      # 0x11e14
leaq 0x406c(%rip), %rdx      # 0x11920
movl $0x124, %ecx            # imm = 0x124
callq 0x3940
movl $0x0, 0x24(%rsp)
jmp 0xd8ef
jmp 0xd8ca
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdb20
movl %eax, 0x14(%rsp)
movl $0x2, %edi
callq 0x9aa0
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirplugins.c
// Function: sir_plugin_cache_add
sirpluginid _sir_plugin_cache_add(sir_plugincache* spc, sir_plugin* plugin) {
#if !defined(SIR_NO_PLUGINS)
    if (!_sir_validptr(spc) || !_sir_validptr(plugin))
        return 0U;

    if (spc->count >= SIR_MAXPLUGINS) {
        (void)_sir_seterror(_SIR_E_NOROOM);
        return 0U;
    }

    const sir_plugin* existing = _sir_plugin_cache_find_id(spc, plugin->id);
    if (NULL != existing) {
        _sir_selflog("error: already have plugin (path: '%s', id: %08"PRIx32")",
            existing->path, plugin->id);
        (void)_sir_seterror(_SIR_E_DUPITEM);
        return 0U;
    }

    _sir_selflog("adding plugin (path: %s, id: %08"PRIx32"); count = %zu",
    plugin->path, plugin->id, spc->count + 1);
    spc->plugins[spc->count++] = plugin;
    return plugin->id;
#else
    SIR_UNUSED(spc);
    SIR_UNUSED(plugin);
    return 0U;
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x4309(%rip), %rdx      # 0x11e48
leaq 0x3dda(%rip), %rcx      # 0x11920
movl $0x15c, %r8d            # imm = 0x15C
callq 0xd900
testb $0x1, %al
jne 0xdb57
jmp 0xdb7e
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x42e0(%rip), %rdx      # 0x11e48
leaq 0x3db1(%rip), %rcx      # 0x11920
movl $0x15c, %r8d            # imm = 0x15C
callq 0xd900
testb $0x1, %al
jne 0xdb8b
movl $0x0, 0x24(%rsp)
jmp 0xdc8b
movq 0x18(%rsp), %rax
cmpq $0x10, 0x80(%rax)
jb 0xdbc4
movl $0x80060000, %edi       # imm = 0x80060000
leaq 0x42a2(%rip), %rsi      # 0x11e48
leaq 0x3d73(%rip), %rdx      # 0x11920
movl $0x160, %ecx            # imm = 0x160
callq 0x3940
movl $0x0, 0x24(%rsp)
jmp 0xdc8b
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x60(%rax), %esi
callq 0xdf70
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpq 0x8(%rsp), %rax
je 0xdc29
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rax
movl 0x60(%rax), %edx
leaq 0x4263(%rip), %rdi      # 0x11e5e
movb $0x0, %al
callq 0xd060
movl $0x80040000, %edi       # imm = 0x80040000
leaq 0x423a(%rip), %rsi      # 0x11e48
leaq 0x3d0b(%rip), %rdx      # 0x11920
movl $0x168, %ecx            # imm = 0x168
callq 0x3940
movl $0x0, 0x24(%rsp)
jmp 0xdc8b
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rax
movl 0x60(%rax), %edx
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rcx
addq $0x1, %rcx
leaq 0x4240(%rip), %rdi      # 0x11e90
movb $0x0, %al
callq 0xd060
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rsi
movq 0x80(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x80(%rsi)
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movl 0x60(%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl $0x80010000, %edi       # imm = 0x80010000
leaq 0x4170(%rip), %rsi      # 0x11e24
leaq 0x3c65(%rip), %rdx      # 0x11920
movl $0x132, %ecx            # imm = 0x132
callq 0x3940
callq 0x9d10
testb $0x1, %al
jne 0xdcd5
movb $0x0, 0x17(%rsp)
jmp 0xdd3a
movl $0x2, %edi
callq 0x9650
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xdd10
movl $0x800f0000, %edi       # imm = 0x800F0000
leaq 0x412c(%rip), %rsi      # 0x11e24
leaq 0x3c21(%rip), %rdx      # 0x11920
movl $0x137, %ecx            # imm = 0x137
callq 0x3940
movb $0x0, 0x17(%rsp)
jmp 0xdd3a
jmp 0xdd12
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0xdd50
andb $0x1, %al
movb %al, 0x7(%rsp)
movl $0x2, %edi
callq 0x9aa0
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirplugins.c
// Function: sir_plugin_cache_rem
bool _sir_plugin_cache_rem(sir_plugincache* spc, sirpluginid id) {
#if !defined(SIR_NO_PLUGINS)
    if (!_sir_validptr(spc))
        return false;

    for (size_t n = 0; n < spc->count; n++) {
        if (spc->plugins[n]->id == id) {
            _sir_selflog("removing plugin (path: '%s', id: %"PRIx32"); count = %zu",
                spc->plugins[n]->path, spc->plugins[n]->id, spc->count - 1);

            _sir_plugin_destroy(&spc->plugins[n]);

            for (size_t i = n; i < spc->count - 1; i++) {
                spc->plugins[i] = spc->plugins[i + 1];
                spc->plugins[i + 1] = NULL;
            }

            spc->count--;
            return true;
        }
    }

    return _sir_seterror(_SIR_E_NOITEM);
#else
    SIR_UNUSED(spc);
    SIR_UNUSED(id);
    return false;
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x4169(%rip), %rdx      # 0x11ed7
leaq 0x3bab(%rip), %rcx      # 0x11920
movl $0x197, %r8d            # imm = 0x197
callq 0xd900
testb $0x1, %al
jne 0xdd8e
movb $0x0, 0x27(%rsp)
jmp 0xded2
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x80(%rcx), %rax
jae 0xdeaf
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x60(%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0xde9a
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x60(%rax), %edx
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rcx
subq $0x1, %rcx
leaq 0x40eb(%rip), %rdi      # 0x11eed
movb $0x0, %al
callq 0xd060
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xd070
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x80(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xde7c
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq $0x0, 0x8(%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0xde28
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x80(%rax)
movb $0x1, 0x27(%rsp)
jmp 0xded2
jmp 0xde9c
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xdd97
movl $0x80050000, %edi       # imm = 0x80050000
leaq 0x401c(%rip), %rsi      # 0x11ed7
leaq 0x3a5e(%rip), %rdx      # 0x11920
movl $0x1ab, %ecx            # imm = 0x1AB
callq 0x3940
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirplugins.c
// Function: sir_plugin_cache_find
sir_plugin* _sir_plugin_cache_find(const sir_plugincache* spc, const void* match,
    sir_plugin_pred pred) {
#if !defined(SIR_NO_PLUGINS)
    if (!_sir_validptr(spc) || !_sir_validptr(match) || !_sir_validfnptr(pred))
        return NULL;

    for (size_t n = 0; n < spc->count; n++) {
        if (pred(match, spc->plugins[n]))
            return spc->plugins[n];
    }

    return NULL;
#else
    SIR_UNUSED(spc);
    SIR_UNUSED(match);
    SIR_UNUSED(pred);
    return NULL;
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x3efc(%rip), %rdx      # 0x11ec0
leaq 0x3955(%rip), %rcx      # 0x11920
movl $0x184, %r8d            # imm = 0x184
callq 0xd900
testb $0x1, %al
jne 0xdfdc
jmp 0xe02c
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x3ed3(%rip), %rdx      # 0x11ec0
leaq 0x392c(%rip), %rcx      # 0x11920
movl $0x184, %r8d            # imm = 0x184
callq 0xd900
testb $0x1, %al
jne 0xe005
jmp 0xe02c
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x3eaa(%rip), %rdx      # 0x11ec0
leaq 0x3903(%rip), %rcx      # 0x11920
movl $0x184, %r8d            # imm = 0x184
callq 0xdee0
testb $0x1, %al
jne 0xe037
movq $0x0, 0x20(%rsp)
jmp 0xe09d
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x80(%rcx), %rax
jae 0xe094
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq (%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
testb $0x1, %al
jne 0xe070
jmp 0xe084
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
jmp 0xe09d
jmp 0xe086
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0xe03f
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x3e55(%rip), %rdx      # 0x11f1f
leaq 0x384f(%rip), %rcx      # 0x11920
movl $0x1b5, %r8d            # imm = 0x1B5
callq 0xd900
testb $0x1, %al
jne 0xe0e7
movb $0x0, 0x17(%rsp)
jmp 0xe161
jmp 0xe0e9
movq 0x8(%rsp), %rax
cmpq $0x0, 0x80(%rax)
jbe 0xe14b
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rax
subq $0x1, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xd070
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x80(%rax)
jmp 0xe0e9
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x88, %edx
callq 0x21c0
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movw %di, %ax
movw %ax, 0x2e(%rsp)
movl $0x3, %edi
callq 0x9650
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xe48e
movl $0x800f0000, %edi       # imm = 0x800F0000
leaq 0x3c01(%rip), %rsi      # 0x12070
leaq 0x3c0c(%rip), %rdx      # 0x12082
movl $0x33, %ecx
callq 0x3940
movq $0x0, 0x30(%rsp)
jmp 0xe5a8
jmp 0xe490
leaq 0x1ef0(%rip), %rax      # 0x10387
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x7, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq 0x8(%rsp), %rax
shrq %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
imulq $0x3c, (%rsp), %rcx
addq %rcx, %rax
movzwl (%rax), %eax
movzwl 0x2e(%rsp), %ecx
cmpl %ecx, %eax
jne 0xe4f9
movq 0x20(%rsp), %rax
movq (%rax), %rax
imulq $0x3c, (%rsp), %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
jmp 0xe594
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0xe50a
jmp 0xe594
movq 0x20(%rsp), %rax
movq (%rax), %rax
imulq $0x3c, (%rsp), %rcx
addq %rcx, %rax
movzwl (%rax), %edx
movzwl 0x2e(%rsp), %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %eax
cmpl %esi, %edx
cmovll %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0xe555
movq (%rsp), %rax
subq $0x1, %rax
cmpq 0x10(%rsp), %rax
jb 0xe555
movq (%rsp), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xe577
movq (%rsp), %rax
addq $0x1, %rax
cmpq 0x8(%rsp), %rax
ja 0xe573
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xe575
jmp 0xe594
jmp 0xe577
movq 0x10(%rsp), %rax
addq 0x8(%rsp), %rax
shrq %rax
movq %rax, (%rsp)
movb $0x1, %al
testb $0x1, %al
jne 0xe4bf
jmp 0xe594
movl $0x3, %edi
callq 0x9aa0
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movw %di, %ax
movw %ax, -0xa(%rsp)
movzwl -0xa(%rsp), %eax
movl %eax, -0x10(%rsp)
subl $0x1, %eax
je 0xeb37
jmp 0xeae8
movl -0x10(%rsp), %eax
subl $0x2, %eax
je 0xeb45
jmp 0xeaf3
movl -0x10(%rsp), %eax
subl $0x4, %eax
je 0xeb53
jmp 0xeafe
movl -0x10(%rsp), %eax
subl $0x8, %eax
je 0xeb61
jmp 0xeb09
movl -0x10(%rsp), %eax
subl $0x10, %eax
je 0xeb6f
jmp 0xeb14
movl -0x10(%rsp), %eax
subl $0x20, %eax
je 0xeb7d
jmp 0xeb1f
movl -0x10(%rsp), %eax
subl $0x40, %eax
je 0xeb8b
jmp 0xeb2a
movl -0x10(%rsp), %eax
subl $0x80, %eax
je 0xeb99
jmp 0xeba7
leaq 0x34d2(%rip), %rax      # 0x12010
movq %rax, -0x8(%rsp)
jmp 0xebb3
leaq 0x34d0(%rip), %rax      # 0x1201c
movq %rax, -0x8(%rsp)
jmp 0xebb3
leaq 0x34ce(%rip), %rax      # 0x12028
movq %rax, -0x8(%rsp)
jmp 0xebb3
leaq 0x34cc(%rip), %rax      # 0x12034
movq %rax, -0x8(%rsp)
jmp 0xebb3
leaq 0x34ca(%rip), %rax      # 0x12040
movq %rax, -0x8(%rsp)
jmp 0xebb3
leaq 0x34c8(%rip), %rax      # 0x1204c
movq %rax, -0x8(%rsp)
jmp 0xebb3
leaq 0x34c6(%rip), %rax      # 0x12058
movq %rax, -0x8(%rsp)
jmp 0xebb3
leaq 0x34c4(%rip), %rax      # 0x12064
movq %rax, -0x8(%rsp)
jmp 0xebb3
leaq 0x34aa(%rip), %rax      # 0x12058
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl $0x80010000, %edi       # imm = 0x80010000
leaq 0x34d3(%rip), %rsi      # 0x120a3
leaq 0x34ab(%rip), %rdx      # 0x12082
movl $0x74, %ecx
callq 0x3940
callq 0x9d10
testb $0x1, %al
jne 0xebf4
movb $0x0, 0x37(%rsp)
jmp 0xed14
movl $0x3, %edi
callq 0x9650
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xec32
movl $0x800f0000, %edi       # imm = 0x800F0000
leaq 0x348c(%rip), %rsi      # 0x120a3
leaq 0x3464(%rip), %rdx      # 0x12082
movl $0x79, %ecx
callq 0x3940
movb $0x0, 0x37(%rsp)
jmp 0xed14
jmp 0xec34
movb $0x1, 0x27(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0x8, 0x18(%rsp)
jae 0xed00
movq 0x28(%rsp), %rax
movq (%rax), %rax
imulq $0x3c, 0x18(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
imulq $0x3c, 0x18(%rsp), %rcx
addq %rcx, %rax
movzwl (%rax), %edi
callq 0xead0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, 0x4(%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %edi
movq 0x28(%rsp), %rax
movq (%rax), %rsi
imulq $0x3c, 0x18(%rsp), %rax
addq %rax, %rsi
addq $0x4, %rsi
movq 0x28(%rsp), %rax
movq (%rax), %rdx
imulq $0x3c, 0x18(%rsp), %rax
addq %rax, %rdx
addq $0x10, %rdx
callq 0xe7c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0xecdb
jmp 0xece3
movb 0x27(%rsp), %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xec42
movl $0x3, %edi
callq 0x9aa0
movb 0x27(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl 0x10(%rsp), %edi
leaq 0x30ee(%rip), %rsi      # 0x12161
leaq 0x3008(%rip), %rdx      # 0x12082
movl $0xc4, %ecx
callq 0x8350
testb $0x1, %al
jne 0xf092
movb $0x0, 0x17(%rsp)
jmp 0xf162
movl $0x3, %edi
callq 0x9650
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xf0d0
movl $0x800f0000, %edi       # imm = 0x800F0000
leaq 0x30ac(%rip), %rsi      # 0x12161
leaq 0x2fc6(%rip), %rdx      # 0x12082
movl $0xc7, %ecx
callq 0x3940
movb $0x0, 0x17(%rsp)
jmp 0xf162
jmp 0xf0d2
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
cmpl 0x10(%rsp), %eax
je 0xf141
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl %ecx, (%rax)
movl 0x4(%rsp), %esi
movl 0x10(%rsp), %edx
leaq 0x3063(%rip), %rdi      # 0x12173
movb $0x0, %al
callq 0xf050
callq 0xebc0
testb $0x1, %al
jne 0xf13f
leaq 0x1fa8(%rip), %rdi      # 0x110cf
movb $0x0, %al
callq 0xf050
movl $0x3, %edi
callq 0x9aa0
movb $0x0, 0x17(%rsp)
jmp 0xf162
jmp 0xf153
movl 0x10(%rsp), %esi
leaq 0x3048(%rip), %rdi      # 0x12194
movb $0x0, %al
callq 0xf050
movl $0x3, %edi
callq 0x9aa0
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x20(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl -0x20(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq 0x2eb5(%rip), %rax      # 0x71f0
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
shlq $0x2, %rax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl -0x34(%rbp), %edx
subl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
imull %ecx, %eax
cltq
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x2120
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq $0x2, %rdx
callq 0x4500
movl -0x28(%rbp), %eax
addl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jl 0x4377
movl -0x2c(%rbp), %ecx
movl -0x4c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x43e6
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x2120
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq $0x2, %rdx
callq 0x4500
movl -0x28(%rbp), %eax
addl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x43b3
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movq 0x10(%rbp), %rcx
callq 0x4400
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
callq 0x10b0
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
shlq $0x2, %rdi
imulq 0x38(%rsp), %rdi
callq 0x1080
movq 0x30(%rsp), %rcx
movq %rax, (%rcx)
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
shlq $0x2, %rdi
imulq 0x38(%rsp), %rdi
callq 0x1080
movq 0x28(%rsp), %rcx
movq %rax, (%rcx)
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x40(%rsp), %rcx
imulq 0x38(%rsp), %rcx
cmpq %rcx, %rax
jae 0x12a8
movq 0x20(%rsp), %rdi
callq 0x12b0
cvtsd2ss %xmm0, %xmm0
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rsp)
movss %xmm0, (%rax)
movq 0x20(%rsp), %rdi
callq 0x12b0
cvtsd2ss %xmm0, %xmm0
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x8(%rsp)
movss %xmm0, (%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x123d
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movl $0x0, 0x54(%rsp)
movl %edi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq $0x3e8, 0x30(%rsp)      # imm = 0x3E8
movq $0x7d0, 0x28(%rsp)      # imm = 0x7D0
movq 0x28(%rsp), %rdi
shlq $0x2, %rdi
imulq 0x28(%rsp), %rdi
callq 0x1080
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x38(%rsp), %rcx
callq 0x11d0
movq 0x40(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x38(%rsp)
xorl %edi, %edi
callq 0x1090
movl $0x1, %edi
callq 0x10a0
movq %rax, 0x18(%rsp)
callq 0x1030
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x10c0
callq 0x1040
movq %rax, 0x8(%rsp)
callq 0x1050
movq 0x8(%rsp), %rcx
leaq 0xc59(%rip), %rdi       # 0x2010
movb $0x1, %al
callq *%rcx
movl $0x1, %edi
callq 0x1090
movl $0x1, %edi
callq 0x10a0
movq %rax, 0x18(%rsp)
callq 0x1030
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x10c0
callq 0x1040
movq %rax, 0x10(%rsp)
callq 0x1050
movq 0x10(%rsp), %rcx
leaq 0xc0b(%rip), %rdi       # 0x202b
movb $0x1, %al
callq *%rcx
movq 0x40(%rsp), %rax
addq $-0x4, %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
addq $-0x4, %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1070
movq 0x38(%rsp), %rdi
callq 0x1070
movq 0x20(%rsp), %rdi
callq 0x1070
xorl %eax, %eax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
je 0x243f
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl 0x18(%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x9, -0x18(%rbp)
jne 0x23fe
movl -0x10(%rbp), %eax
orl $0x7, %eax
movl %eax, -0x10(%rbp)
jmp 0x2415
cmpl $0x20, -0x18(%rbp)
jl 0x240a
cmpl $0x7f, -0x18(%rbp)
jne 0x2413
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2415
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0xe710(%rip), %rcx      # 0x10b38
cmpl (%rcx), %eax
jle 0x242e
jmp 0x243f
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x23c6
movslq -0x14(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x24e9
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0x25b0
movl %eax, -0x4(%rbp)
jmp 0x259f
jmp 0x24eb
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x2598
leaq 0xe552(%rip), %rax      # 0x10a58
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x257d
leaq 0xe541(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0xe51b(%rip), %rcx      # 0x10a48
movq (%rcx), %rcx
cmpq 0x28(%rcx), %rax
jne 0x253f
movl $0x0, -0x4(%rbp)
jmp 0x259f
movq -0x18(%rbp), %rcx
leaq 0xe50e(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movslq 0x14(%rax), %rcx
leaq 0xe4f8(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x20(%rax)
leaq 0xe4ea(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x3b(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x3b(%rax)
jmp 0x2593
leaq 0xe4d4(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x24eb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x25d9
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0x24c0
movl %eax, -0x4(%rbp)
jmp 0x26a4
jmp 0x25db
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x269d
leaq 0xe462(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x20(%rax), %rax
leaq 0xe454(%rip), %rcx      # 0x10a58
movq (%rcx), %rcx
movq 0x18(%rcx), %rcx
movslq 0x14(%rcx), %rcx
cmpq %rcx, %rax
jne 0x2682
leaq 0xe43d(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rax
leaq 0xe41f(%rip), %rcx      # 0x10a48
movq (%rcx), %rcx
cmpq 0x28(%rcx), %rax
jne 0x263b
movl $0x0, -0x4(%rbp)
jmp 0x26a4
leaq 0xe416(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
leaq 0xe405(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
leaq 0xe3f7(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq $0x0, 0x20(%rax)
leaq 0xe3e5(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x3b(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x3b(%rax)
jmp 0x2698
leaq 0xe3cf(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x25db
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x16(%rbp), %rsi
leaq 0x993b(%rip), %rdi      # 0xc004
movl $0xa, %ecx
movl %ecx, %edx
callq 0x57e0
movl %eax, -0x28(%rbp)
cmpl $0x1, %eax
je 0x26e8
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2787
movsbl -0x16(%rbp), %eax
cmpl $0x0, %eax
jne 0x26fd
movl $0x2, -0x4(%rbp)
jmp 0x2787
leaq -0x16(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0xa, %edx
callq 0x21a0
movl %eax, -0x24(%rbp)
leaq -0x16(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x272e
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x272e
cmpl $0x1, -0xc(%rbp)
jge 0x2745
leaq 0x98db(%rip), %rdi      # 0xc010
movb $0x0, %al
callq 0x56d0
movl $0x0, -0x4(%rbp)
jmp 0x2787
leaq 0xe2fc(%rip), %rax      # 0x10a48
movq (%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
leaq 0xe2fb(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
leaq 0xe2ed(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq $0x0, 0x20(%rax)
movl -0x8(%rbp), %edi
movl -0x24(%rbp), %esi
subl $0x1, %esi
callq 0x2790
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x27b9
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0x2960
movl %eax, -0x4(%rbp)
jmp 0x288d
leaq 0xe290(%rip), %rax      # 0x10a50
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x27dc
xorl %edi, %edi
callq 0x88a0
movl %eax, %ecx
leaq 0xe35e(%rip), %rax      # 0x10b38
movl %ecx, (%rax)
leaq 0xe295(%rip), %rax      # 0x10a78
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0xe289(%rip), %rax      # 0x10a78
movl %ecx, (%rax)
leaq 0xe260(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x2830
movq -0x18(%rbp), %rax
leaq 0xe225(%rip), %rcx      # 0x10a48
movq (%rcx), %rcx
cmpq 0x28(%rcx), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2839
jmp 0x2846
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2803
movq -0x18(%rbp), %rcx
leaq 0xe207(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x23b0
movq %rax, %rcx
leaq 0xe1ed(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x20(%rax)
leaq 0xe1df(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x3b(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x3b(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0xe197(%rip), %rax      # 0x10a48
movq (%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
leaq 0xe196(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
leaq 0xe188(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq $0x0, 0x20(%rax)
leaq 0xe176(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x3b(%rax), %ecx
orl $0x8, %ecx
movb %cl, 0x3b(%rax)
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0xe137(%rip), %rax      # 0x10a48
movq (%rax), %rax
movq 0x28(%rax), %rcx
leaq 0xe139(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
leaq 0xe12b(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq $0x0, 0x20(%rax)
leaq 0xe119(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x3b(%rax), %ecx
orl $0x8, %ecx
movb %cl, 0x3b(%rax)
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x2989
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0x2790
movl %eax, -0x4(%rbp)
jmp 0x2a62
leaq 0xe0c0(%rip), %rax      # 0x10a50
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x29ac
xorl %edi, %edi
callq 0x88a0
movl %eax, %ecx
leaq 0xe18e(%rip), %rax      # 0x10b38
movl %ecx, (%rax)
leaq 0xe0c5(%rip), %rax      # 0x10a78
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0xe0b9(%rip), %rax      # 0x10a78
movl %ecx, (%rax)
leaq 0xe090(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x2a04
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0xe051(%rip), %rcx      # 0x10a48
movq (%rcx), %rcx
cmpq 0x28(%rcx), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2a0d
jmp 0x2a1b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x29d3
movq -0x18(%rbp), %rcx
leaq 0xe032(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x23b0
movq %rax, %rcx
leaq 0xe018(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x20(%rax)
leaq 0xe00a(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x3b(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x3b(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x2aa7
leaq 0xdfcd(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x39(%rax), %eax
subl $0x2, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x2aa5
movl $0x1, -0xc(%rbp)
jmp 0x2ad9
cmpl $0x0, -0xc(%rbp)
jge 0x2ac2
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0x2b90
movl %eax, -0x4(%rbp)
jmp 0x2b7f
leaq 0xdf8f(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x39(%rax), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x2ad9
leaq 0xdf78(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x2b18
movq -0x18(%rbp), %rax
leaq 0xdf3d(%rip), %rcx      # 0x10a48
movq (%rcx), %rcx
cmpq 0x28(%rcx), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2b21
jmp 0x2b2e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2aeb
movq -0x18(%rbp), %rcx
leaq 0xdf1f(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
leaq 0xdf0d(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
leaq 0xdeff(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq $0x0, 0x20(%rax)
leaq 0xdeed(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x3b(%rax), %ecx
orl $0x8, %ecx
movb %cl, 0x3b(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)