LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/objects.c
// Function: moonsndfile_newuserdata
ud_t *newuserdata(lua_State *L, void *handle, const char *mt)
    {
    ud_t *ud;
    /* we use handle as search key */
    ud = (ud_t*)udata_new(L, sizeof(ud_t), (uint64_t)(uintptr_t)handle, mt);
    memset(ud, 0, sizeof(ud_t));
    ud->handle = handle;
    MarkValid(ud);
    return ud;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0x50, %esi
callq 0x40c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x4310
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl 0x18(%rax), %ecx
orl $0x1, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/objects.c
// Function: moonsndfile_freeuserdata
int freeuserdata(lua_State *L, ud_t *ud)
    {
    /* The 'Valid' mark prevents double calls when an object is explicitly destroyed, 
     * and subsequently deleted also by the GC (the ud sticks around until the GC
     * collects it, so we mark it as invalid when the object is explicitly destroyed
     * by the script, or implicitly destroyed because child of a destroyed object). */
    if(!IsValid(ud)) return 0;
    CancelValid(ud);
    if(ud->info) 
        Free(L, ud->info);
    udata_free(L, (uint64_t)(uintptr_t)ud->handle);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x1, %eax
je 0xc936
movl $0x0, 0x14(%rsp)
jmp 0xc97f
jmp 0xc938
movq (%rsp), %rax
movl 0x18(%rax), %ecx
andl $-0x2, %ecx
movq (%rsp), %rax
movl %ecx, 0x18(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0xc966
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x43a0
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
callq 0x46f0
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/rawreadwrite.c
// Function: ReadRaw
static int ReadRaw(lua_State *L)
    {
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    size_t bytes = luaL_checkinteger(L, 2);
    char *ptr = (char*)Malloc(L, bytes);
    sf_count_t nbytes = sf.read_raw(sndfile, ptr, bytes);
    lua_pushlstring(L, ptr, nbytes);
    Free(L, ptr);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x51f9(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x4470
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x41d0
movq %rax, 0x8(%rsp)
movq 0xa109(%rip), %rax      # 0x16fe0
movq 0x78(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x4650
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x43a0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/rawreadwrite.c
// Function: WriteRaw
static int WriteRaw(lua_State *L)
    {
    size_t bytes;
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    const char *ptr = luaL_checklstring(L, 2, &bytes);
    sf_count_t nbytes = sf.write_raw(sndfile, ptr, bytes);
    lua_pushinteger(L, nbytes);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x5159(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
leaq 0x18(%rsp), %rdx
callq 0x4380
movq %rax, 0x8(%rsp)
movq 0xa078(%rip), %rax      # 0x16fe0
movq 0x80(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x4320
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/readwrite.c
// Function: Seek
static int Seek(lua_State *L)
    {
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    sf_count_t frames = luaL_checkinteger(L, 2);
    int whence = checkwhence(L, 3);
    sf_count_t offset = sf.seek(sndfile, frames, whence) ;
    if(offset == -1)
        return nil_sndfileerror(L, sndfile);
    lua_pushinteger(L, offset);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x5069(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x4470
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x5, %esi
movl $0x3, %edx
callq 0x4120
movl %eax, 0x14(%rsp)
movq 0x9f75(%rip), %rax      # 0x16fe0
movq 0x50(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq *%rax
movq %rax, 0x8(%rsp)
cmpq $-0x1, 0x8(%rsp)
jne 0xd0a1
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4590
movl %eax, 0x34(%rsp)
jmp 0xd0b8
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4320
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/readwrite.c
// Function: CurrentByterate
static int CurrentByterate(lua_State *L)
    {
    int val;
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    if(!sf.current_byterate) //CheckPfn(L, current_byterate, 1,0,26);
        return 0;
    val = sf.current_byterate(sndfile);
    if(val == -1) 
        return 0; /* unknown */
    lua_pushinteger(L, val);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x4f59(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x8(%rsp)
movq 0x9e91(%rip), %rax      # 0x16fe0
cmpq $0x0, 0x70(%rax)
jne 0xd160
movl $0x0, 0x24(%rsp)
jmp 0xd19e
movq 0x9e79(%rip), %rax      # 0x16fe0
movq 0x70(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0xd187
movl $0x0, 0x24(%rsp)
jmp 0xd19e
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x4320
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/readwrite.c
// Function: SetBitrateMode
static int SetBitrateMode(lua_State *L)
    {
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    int val = checkbitratemode(L, 2);
    sf.command(sndfile, SFC_SET_BITRATE_MODE, NULL, val);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x47e9(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0xc, %esi
movl $0x2, %edx
callq 0x4120
movl %eax, 0x4(%rsp)
movq 0x9709(%rip), %rax      # 0x16fe0
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %ecx
movl $0x1305, %esi           # imm = 0x1305
xorl %edx, %edx
callq *%rax
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/readwrite.c
// Function: GetBitrateMode
static int GetBitrateMode(lua_State *L)
    {
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    int val = sf.command(sndfile, SFC_GET_BITRATE_MODE, NULL, 0);
    pushbitratemode(L, val);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x4779(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x8(%rsp)
movq 0x96b1(%rip), %rax      # 0x16fe0
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rdi
movl $0x1304, %esi           # imm = 0x1304
xorl %ecx, %ecx
movl %ecx, %edx
xorl %ecx, %ecx
callq *%rax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %edx
movl $0xc, %esi
callq 0x4110
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/sndfile.c
// Function: GetFileinfo
static int GetFileinfo(lua_State *L)
    {
    ud_t *ud;
    sndfile_t sndfile = checksndfile(L, 1, &ud);
    update_sfinfo(L, sndfile, ud);
    pushinfo(L, &ud->sfinfo);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x8(%rsp), %rdx
leaq 0x4338(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x41e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
callq 0x43b0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/sndfile.c
// Function: GetFormat
static int GetFormat(lua_State *L)
    {
    ud_t *ud;
    sndfile_t sndfile = checksndfile(L, 1, &ud);
    update_sfinfo(L, sndfile, ud);
    pushformat(L, ud->sfinfo.format & SF_FORMAT_TYPEMASK);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x8(%rsp), %rdx
leaq 0x42d8(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x41e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x30(%rax), %edx
andl $0xfff0000, %edx        # imm = 0xFFF0000
movl $0x1, %esi
callq 0x4110
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/sndfile.c
// Function: GetSubformat
static int GetSubformat(lua_State *L)
    {
    ud_t *ud;
    sndfile_t sndfile = checksndfile(L, 1, &ud);
    update_sfinfo(L, sndfile, ud);
    pushsubformat(L, ud->sfinfo.format & SF_FORMAT_SUBMASK);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x8(%rsp), %rdx
leaq 0x4268(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x41e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x30(%rax), %edx
andl $0xffff, %edx           # imm = 0xFFFF
movl $0x2, %esi
callq 0x4110
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/sndfile.c
// Function: GetEndianness
static int GetEndianness(lua_State *L)
    {
    ud_t *ud;
    sndfile_t sndfile = checksndfile(L, 1, &ud);
    update_sfinfo(L, sndfile, ud);
    pushendianness(L, ud->sfinfo.format & SF_FORMAT_ENDMASK);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x8(%rsp), %rdx
leaq 0x41f8(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x41e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x30(%rax), %edx
andl $0x30000000, %edx       # imm = 0x30000000
movl $0x3, %esi
callq 0x4110
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/sndfile.c
// Function: GetSeekable
static int GetSeekable(lua_State *L)
    {
    ud_t *ud;
    sndfile_t sndfile = checksndfile(L, 1, &ud);
    update_sfinfo(L, sndfile, ud);
    lua_pushboolean(L, ud->sfinfo.seekable);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x8(%rsp), %rdx
leaq 0x3fa8(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x41e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x38(%rax), %esi
callq 0x4550
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/sndfile.c
// Function: SetString
static int SetString(lua_State *L)
    {
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    int str_type = checkstringtype(L, 2);
    const char *str = luaL_checkstring(L, 3);
    if(sf.set_string(sndfile, str_type, str))
        return sndfileerror(L, sndfile);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x3f09(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x4, %esi
movl $0x2, %edx
callq 0x4120
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x4380
movq %rax, (%rsp)
movq 0x8e12(%rip), %rax      # 0x16fe0
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movq (%rsp), %rdx
callq *%rax
cmpl $0x0, %eax
je 0xe1fb
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4340
movl %eax, 0x24(%rsp)
jmp 0xe203
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/sndfile.c
// Function: GetString
static int GetString(lua_State *L)
    {
    int str_type = checkstringtype(L, 2);
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    const char *str = sf.get_string(sndfile, str_type);
    if(!str) return 0;
    lua_pushstring(L, str);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x4, %esi
movl $0x2, %edx
callq 0x4120
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x3e51(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x8(%rsp)
movq 0x8d89(%rip), %rax      # 0x16fe0
movq 0x60(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq *%rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xe27b
movl $0x0, 0x24(%rsp)
jmp 0xe291
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x4780
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/sndfile.c
// Function: GetEmbedFileInfo
static int GetEmbedFileInfo (lua_State *L)
    {
    SF_EMBED_FILE_INFO info;
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    if(sf.command(sndfile, SFC_GET_EMBED_FILE_INFO, &info, sizeof(info)) != 0)
        return sndfileerror(L, sndfile);
    lua_pushinteger(L, info.offset);
    lua_pushinteger(L, info.length);
    return 2;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x3dd9(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, (%rsp)
movq 0x8d12(%rip), %rax      # 0x16fe0
movq 0x40(%rax), %rax
movq (%rsp), %rdi
movl $0x10b0, %esi           # imm = 0x10B0
leaq 0x8(%rsp), %rdx
movl $0x10, %ecx
callq *%rax
cmpl $0x0, %eax
je 0xe300
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x4340
movl %eax, 0x24(%rsp)
jmp 0xe326
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4320
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4320
movl $0x2, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/sndfile.c
// Function: Create
static int Create(lua_State *L, sndfile_t sndfile, const SF_INFO *info)
    {
    ud_t *ud;
    ud = newuserdata(L, sndfile, SNDFILE_MT);
    ud->parent_ud = NULL;
    ud->destructor = freesndfile;
    memcpy(&ud->sfinfo, info, sizeof(SF_INFO));
    TRACE_CREATE(sndfile, "sndfile");
    pushinfo(L, &ud->sfinfo);
    return 2;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x3b13(%rip), %rdx      # 0x12097
callq 0x46e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
leaq 0x79(%rip), %rcx        # 0xe620
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x38(%rax)
movq 0x8a1d(%rip), %rax      # 0x16ff8
cmpl $0x0, (%rax)
je 0xe5f3
movq 0x18(%rsp), %rsi
leaq 0x4fae(%rip), %rdi      # 0x1359a
movb $0x0, %al
callq 0x4290
jmp 0xe5f5
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
callq 0x43b0
movl $0x2, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/sndfile.c
// Function: freesndfile
static int freesndfile(lua_State *L, ud_t *ud)
    {
    int ec;
    sndfile_t sndfile = (sndfile_t)ud->handle;
    chunknode_t *chunklist = ud->chunklist;
    if(!freeuserdata(L, ud)) return 0;
    TRACE_DELETE(sndfile, "sndfile");
    ec = sf.close(sndfile);
    freechunks(L, chunklist);
    if(ec != 0) 
        return luaL_error(L, sf.error_number(ec));
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4720
cmpl $0x0, %eax
jne 0xe66a
movl $0x0, 0x34(%rsp)
jmp 0xe6f2
jmp 0xe66c
movq 0x8985(%rip), %rax      # 0x16ff8
cmpl $0x0, (%rax)
je 0xe68b
movq 0x10(%rsp), %rsi
leaq 0x4f29(%rip), %rdi      # 0x135ad
movb $0x0, %al
callq 0x4290
jmp 0xe68d
movq 0x894c(%rip), %rax      # 0x16fe0
movq 0x108(%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x47b0
cmpl $0x0, 0x1c(%rsp)
je 0xe6ea
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x8914(%rip), %rax      # 0x16fe0
movq 0x28(%rax), %rax
movl 0x1c(%rsp), %edi
callq *%rax
movq (%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x46c0
movl %eax, 0x34(%rsp)
jmp 0xe6f2
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/structs.c
// Function: moonsndfile_pushinfo
int pushinfo(lua_State *L, SF_INFO *p)
    {
    lua_newtable(L);
    lua_pushinteger(L, p->format); lua_setfield(L, -2, "code");
    pushformat(L, FORMAT(p->format)); lua_setfield(L, -2, "format");
    pushsubformat(L, SUBFORMAT(p->format)); lua_setfield(L, -2, "subformat");
    pushendianness(L, ENDIANNESS(p->format)); lua_setfield(L, -2, "endianness");
    lua_pushinteger(L, p->frames); lua_setfield(L, -2, "frames");
    lua_pushinteger(L, p->samplerate); lua_setfield(L, -2, "samplerate");
    lua_pushinteger(L, p->channels); lua_setfield(L, -2, "channels");
    lua_pushinteger(L, p->sections); lua_setfield(L, -2, "sections");
    lua_pushboolean(L, p->seekable); lua_setfield(L, -2, "seekable");
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4220
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq 0x10(%rax), %rsi
callq 0x4320
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x4ad7(%rip), %rdx      # 0x13627
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %edx
andl $0xfff0000, %edx        # imm = 0xFFF0000
movl $0x1, %esi
callq 0x4110
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x427e(%rip), %rdx      # 0x12e01
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %edx
andl $0xffff, %edx           # imm = 0xFFFF
movl $0x2, %esi
callq 0x4110
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x4a8d(%rip), %rdx      # 0x13643
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %edx
andl $0x30000000, %edx       # imm = 0x30000000
movl $0x3, %esi
callq 0x4110
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x4292(%rip), %rdx      # 0x12e7b
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x4320
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x48dd(%rip), %rdx      # 0x134ee
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rsi
callq 0x4320
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x3642(%rip), %rdx      # 0x1227c
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq 0xc(%rax), %rsi
callq 0x4320
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x355a(%rip), %rdx      # 0x121bd
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq 0x14(%rax), %rsi
callq 0x4320
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x4869(%rip), %rdx      # 0x134f5
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x18(%rax), %esi
callq 0x4550
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x484a(%rip), %rdx      # 0x134fe
callq 0x4300
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/structs.c
// Function: moonsndfile_pushformatinfo
int pushformatinfo(lua_State *L, SF_FORMAT_INFO *p)
    {
    lua_newtable(L);
    pushformat(L, p->format); lua_setfield(L, -2, "format");
    lua_pushinteger(L, p->format); lua_setfield(L, -2, "code");
    lua_pushstring(L, p->name); lua_setfield(L, -2, "name");
    lua_pushstring(L, p->extension); lua_setfield(L, -2, "extension");
    GetSubFormats(L, p->format); lua_setfield(L, -2, "subformats"); 
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4220
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %edx
movl $0x1, %esi
callq 0x4110
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x40ee(%rip), %rdx      # 0x12e01
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq (%rax), %rsi
callq 0x4320
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x48ec(%rip), %rdx      # 0x13627
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x4780
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x4b78(%rip), %rdx      # 0x138dc
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x4780
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x48fe(%rip), %rdx      # 0x1368b
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %esi
callq 0xedd0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x48e1(%rip), %rdx      # 0x13695
callq 0x4300
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/structs.c
// Function: GetSubFormats
static int GetSubFormats(lua_State *L, int format)
/* Expects a formatinfo on top of the stack, and sets the 'subformats' field */
    {
    SF_FORMAT_INFO info;
    SF_INFO sfinfo;
    int i, j, count;
    sf.command(NULL, SFC_GET_FORMAT_SUBTYPE_COUNT, &count, sizeof(count));
    lua_newtable(L);
    memset(&info, 0, sizeof(info));
    memset(&sfinfo, 0, sizeof(sfinfo));
    sfinfo.channels = 1;
    j = 0;
    for(i = 0; i < count; i++)
        {
        info.format = i;
        sf.command(NULL, SFC_GET_FORMAT_SUBTYPE, &info, sizeof(info));
        /* check that the combination fo format and subformat is valid */
        sfinfo.format = (format & SF_FORMAT_TYPEMASK) | info.format;
        if(sf.format_check(&sfinfo))
            {
            sf.command(NULL, SFC_GET_FORMAT_INFO, &info, sizeof(info));
            pushsubformatinfo(L, &info);
            lua_seti(L, -2, ++j);
            }
        }
    return 0;   
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1032, %esi           # imm = 0x1032
leaq 0x4(%rsp), %rdx
movl $0x4, %ecx
movq 0x81e9(%rip), %rax      # 0x16fe0
callq *0x40(%rax)
movq 0x50(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4220
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4310
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x4310
movl $0x1, 0x1c(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0xeef5
movl 0xc(%rsp), %eax
movl %eax, 0x30(%rsp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1033, %esi           # imm = 0x1033
leaq 0x30(%rsp), %rdx
movl $0x18, %ecx
movq 0x816e(%rip), %rax      # 0x16fe0
callq *0x40(%rax)
movl 0x4c(%rsp), %eax
andl $0xfff0000, %eax        # imm = 0xFFF0000
orl 0x30(%rsp), %eax
movl %eax, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x814e(%rip), %rax      # 0x16fe0
callq *0x48(%rax)
cmpl $0x0, %eax
je 0xeee3
xorl %eax, %eax
movl %eax, %edi
movl $0x1028, %esi           # imm = 0x1028
leaq 0x30(%rsp), %rdx
movl $0x18, %ecx
movq 0x812c(%rip), %rax      # 0x16fe0
callq *0x40(%rax)
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x4330
movq 0x50(%rsp), %rdi
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4420
jmp 0xeee5
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xee42
xorl %eax, %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/structs.c
// Function: moonsndfile_pushsubformatinfo
int pushsubformatinfo(lua_State *L, SF_FORMAT_INFO *p)
    {
    lua_newtable(L);
    pushsubformat(L, p->format); lua_setfield(L, -2, "subformat");
    lua_pushinteger(L, p->format); lua_setfield(L, -2, "code");
    lua_pushstring(L, p->name); lua_setfield(L, -2, "name");
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4220
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %edx
movl $0x2, %esi
callq 0x4110
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x4700(%rip), %rdx      # 0x13643
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq (%rax), %rsi
callq 0x4320
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x46bc(%rip), %rdx      # 0x13627
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x4780
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x4948(%rip), %rdx      # 0x138dc
callq 0x4300
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/structs.c
// Function: moonsndfile_pushsimpleformat
int pushsimpleformat(lua_State *L, SF_FORMAT_INFO *p)
    {
    lua_newtable(L);
    lua_pushinteger(L, p->format); lua_setfield(L, -2, "code");
    lua_pushstring(L, p->name); lua_setfield(L, -2, "name");
    lua_pushstring(L, p->extension); lua_setfield(L, -2, "extension");
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4220
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq (%rax), %rsi
callq 0x4320
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x4638(%rip), %rdx      # 0x13627
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x4780
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x48c4(%rip), %rdx      # 0x138dc
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x4780
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x464a(%rip), %rdx      # 0x1368b
callq 0x4300
movl $0x1, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/structs.c
// Function: moonsndfile_pushchunk
int pushchunk(lua_State *L, chunk_t *p)
    {
    lua_newtable(L);
    lua_pushlstring(L, p->id, p->id_size);
    lua_setfield(L, -2, "id");
    if(p->data && p->datalen > 0)
        {
        lua_pushlstring(L, (const char*)p->data, p->datalen);
        lua_setfield(L, -2, "data");
        }
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4220
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x8(%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, %edx
callq 0x4650
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x365e(%rip), %rdx      # 0x129a4
callq 0x4300
movq 0x8(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0xf395
movq 0x8(%rsp), %rax
cmpl $0x0, 0x44(%rax)
jbe 0xf395
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rsi
movq 0x8(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, %edx
callq 0x4650
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x3f7d(%rip), %rdx      # 0x1330d
callq 0x4300
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/utils.c
// Function: moonsndfile_tablelen
int tablelen(lua_State *L, int arg)
/* counts the elements of the table at arg */
    {
    int n = 0;
    if(!lua_istable(L, arg))
        return luaL_error(L, errstring(ERR_TABLE));
    lua_pushnil(L);
    while(lua_next(L, arg) != 0)
        { lua_pop(L, 1); n++; }
    return n;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x4730
cmpl $0x5, %eax
je 0x110b1
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
callq 0x4660
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x46c0
movl %eax, 0x24(%rsp)
jmp 0x110f2
movq 0x18(%rsp), %rdi
callq 0x46d0
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x4140
cmpl $0x0, %eax
je 0x110ea
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4080
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x110bb
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/utils.c
// Function: moonsndfile_testboolean
int testboolean(lua_State *L, int arg, int *err)
    {
    if(!lua_isboolean(L, arg))
        { *err = ERR_TYPE; return 0; }
    *err = 0;
    return lua_toboolean(L, arg);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x4730
cmpl $0x1, %eax
je 0x1167a
movq 0x8(%rsp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movl $0x0, 0x24(%rsp)
jmp 0x11697
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x40d0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/utils.c
// Function: moonsndfile_nil_sndfileerror
int nil_sndfileerror(lua_State *L, sndfile_t sndfile)
    { 
    const char *str = sf.strerror(sndfile);
    lua_pushnil(L);
    lua_pushstring(L, str ? str : "unknown error");
    return 2;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x586b(%rip), %rax      # 0x16fe0
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x46d0
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x117ac
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
jmp 0x117b9
leaq 0x2132(%rip), %rax      # 0x138e5
movq %rax, (%rsp)
jmp 0x117b9
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x4780
movl $0x2, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/version.c
// Function: AddVersions
static int AddVersions(lua_State *L)
    {
    int ec;
    const char *ver;

    lua_pushstring(L, "_VERSION");
    lua_pushstring(L, "MoonSndFile "MOONSNDFILE_VERSION);
    lua_settable(L, -3);

    ver = sf.version_string();
    if(!ver) return luaL_error(L, "cannot determine libsndfile version");
    ec = sscanf(ver, "libsndfile-%u.%u.%u", &VerMajor, &VerMinor, &VerPatch);
    Version = MAKE_VERSION(VerMajor, VerMinor, VerPatch);
    if(ec!=3) return luaL_error(L, "cannot determine libsndfile version");

    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x2016(%rip), %rsi      # 0x138fb
callq 0x4780
movq 0x18(%rsp), %rdi
leaq 0x200e(%rip), %rsi      # 0x13904
callq 0x4780
movq 0x18(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x4530
movq 0x56cf(%rip), %rax      # 0x16fe0
callq *0x68(%rax)
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1193a
movq 0x18(%rsp), %rdi
leaq 0x1fe7(%rip), %rsi      # 0x13914
movb $0x0, %al
callq 0x46c0
movl %eax, 0x24(%rsp)
jmp 0x119ae
movq 0x8(%rsp), %rdi
leaq 0x1ff2(%rip), %rsi      # 0x13938
leaq 0x5c3f(%rip), %rdx      # 0x1758c
leaq 0x5c3c(%rip), %rcx      # 0x17590
leaq 0x5c39(%rip), %r8       # 0x17594
movb $0x0, %al
callq 0x45d0
movl %eax, 0x14(%rsp)
movl 0x5c20(%rip), %eax      # 0x1758c
shll $0x16, %eax
movl 0x5c1b(%rip), %ecx      # 0x17590
shll $0xc, %ecx
orl %ecx, %eax
orl 0x5c14(%rip), %eax      # 0x17594
movl %eax, 0x5c02(%rip)      # 0x17588
cmpl $0x3, 0x14(%rsp)
je 0x119a6
movq 0x18(%rsp), %rdi
leaq 0x1f7b(%rip), %rsi      # 0x13914
movb $0x0, %al
callq 0x46c0
movl %eax, 0x24(%rsp)
jmp 0x119ae
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/version.c
// Function: VersionNumbers
static int VersionNumbers(lua_State *L)
    {
    lua_pushinteger(L, VerMajor);
    lua_pushinteger(L, VerMinor);
    lua_pushinteger(L, VerPatch);
    return 3;
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl 0x5b7d(%rip), %eax      # 0x1758c
movl %eax, %esi
callq 0x4320
movq (%rsp), %rdi
movl 0x5b70(%rip), %eax      # 0x17590
movl %eax, %esi
callq 0x4320
movq (%rsp), %rdi
movl 0x5b63(%rip), %eax      # 0x17594
movl %eax, %esi
callq 0x4320
movl $0x3, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/obstcp-redir.c
// Function: server_listen
static int
server_listen(struct obstcp_keys *keys, unsigned port) {
  const int fd = socket(AF_INET, SOCK_STREAM, 0);
  if (fd < 0) {
    perror("socket");
    return -1;
  }

  struct sockaddr_in sin;
  memset(&sin, 0, sizeof(sin));
  sin.sin_family = PF_INET;
  sin.sin_port = htons(port);

  static const int t = 1;
  static const socklen_t t_len = sizeof(t);
  setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &t, t_len);

  if (bind(fd, (struct sockaddr *) &sin, sizeof(sin))) {
    perror("bind");
    return -1;
  }

  char advert[1024];
  const int advertlen =
    obstcp_advert_base32_create(advert, sizeof(advert), keys,
                                OBSTCP_ADVERT_OBSPORT, port,
                                OBSTCP_ADVERT_END);
  if (advertlen < 0 || advertlen >= sizeof(advert)) {
    perror("advert_create");
    return -1;
  }
  advert[advertlen] = 0;

  fprintf(stderr, "advert: %s\n", advert);

  if (listen(fd, 1)) {
    perror("listen");
    return -1;
  }

  return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x1260
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x1654
leaq 0xbaaf(%rip), %rdi      # 0xd0f2
callq 0x11f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1777
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10e0
movw $0x2, -0x28(%rbp)
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x10a0
movw %ax, -0x26(%rbp)
movl -0x18(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq 0xbae3(%rip), %rcx      # 0xd170
movl $0x4, %r8d
callq 0x1070
movl -0x18(%rbp), %edi
leaq -0x28(%rbp), %rsi
movl $0x10, %edx
callq 0x11b0
cmpl $0x0, %eax
je 0x16c6
leaq 0xba44(%rip), %rdi      # 0xd0f9
callq 0x11f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1777
leaq -0x430(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %r8d
movl $0x400, %esi            # imm = 0x400
movl $0x1, %ecx
xorl %r9d, %r9d
movb $0x0, %al
callq 0x2910
movl %eax, -0x434(%rbp)
cmpl $0x0, -0x434(%rbp)
jl 0x1707
movslq -0x434(%rbp), %rax
cmpq $0x400, %rax            # imm = 0x400
jb 0x171c
leaq 0xb9f0(%rip), %rdi      # 0xd0fe
callq 0x11f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1777
movslq -0x434(%rbp), %rax
movb $0x0, -0x430(%rbp,%rax)
movq 0xe8c6(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq -0x430(%rbp), %rdx
leaq 0xb9c9(%rip), %rsi      # 0xd10c
movb $0x0, %al
callq 0x1150
movl -0x18(%rbp), %edi
movl $0x1, %esi
callq 0x1190
cmpl $0x0, %eax
je 0x1771
leaq 0xb9b5(%rip), %rdi      # 0xd118
callq 0x11f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1777
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/obstcp-redir.c
// Function: connect_cb
static void
connect_cb(int fd, short events, void *arg) {
  struct connection *conn = (struct connection *) arg;

  int err;
  socklen_t errlen = sizeof(err);
  if (getsockopt(conn->outfd, SOL_SOCKET, SO_ERROR, &err, &errlen)) {
    perror("getsockopt for connection result");
    connection_free(conn);
    return;
  }

  if (err) {
    fprintf(stderr, "Connection error: %s\n", strerror(err));
    connection_free(conn);
    return;
  }

  connection_setevents(conn);

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x4, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x1cc(%rax), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x1c(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq 0x1120
cmpl $0x0, %eax
je 0x1a02
leaq 0xb73c(%rip), %rdi      # 0xd12e
callq 0x11f0
movq -0x18(%rbp), %rdi
callq 0x1bc0
jmp 0x1a47
cmpl $0x0, -0x1c(%rbp)
je 0x1a3e
movq 0xe5e9(%rip), %rax      # 0xfff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edi
callq 0x1240
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0xb723(%rip), %rsi      # 0xd14f
movb $0x0, %al
callq 0x1150
movq -0x18(%rbp), %rdi
callq 0x1bc0
jmp 0x1a47
movq -0x18(%rbp), %rdi
callq 0x1a50
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/obstcp-redir.c
// Function: connection_setevents
static void
connection_setevents(struct connection *conn) {
  const short outev = (conn->outqlen < QUEUE_MAX ? EV_READ : 0) |
                      EV_PERSIST |
                      (conn->outqhead ? EV_WRITE : 0);
  const short obsev = (conn->obsqlen < QUEUE_MAX ? EV_READ : 0) |
                      EV_PERSIST |
                      (conn->obsqhead ? EV_WRITE : 0);

  if (conn->outevent.ev_events != outev) {
    if (conn->outevent.ev_events) {
      event_del(&conn->outevent);
    }
    event_set(&conn->outevent, conn->outfd, outev, connection_out_cb, conn);
    event_add(&conn->outevent, NULL);
  }

  if (conn->obsevent.ev_events != obsev) {
    if (conn->obsevent.ev_events) {
      event_del(&conn->obsevent);
    }
    event_set(&conn->obsevent, conn->fd, obsev, connection_obs_cb, conn);
    event_add(&conn->obsevent, NULL);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x300(%rax), %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x8000, %edx           # imm = 0x8000
cmovbl %ecx, %eax
orl $0x10, %eax
movq -0x8(%rbp), %rcx
movq 0x2d0(%rcx), %rsi
xorl %ecx, %ecx
movl $0x4, %edx
cmpq $0x0, %rsi
cmovnel %edx, %ecx
orl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl 0x304(%rax), %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x8000, %edx           # imm = 0x8000
cmovbl %ecx, %eax
orl $0x10, %eax
movq -0x8(%rbp), %rcx
movq 0x2e0(%rcx), %rsi
xorl %ecx, %ecx
movl $0x4, %edx
cmpq $0x0, %rsi
cmovnel %edx, %ecx
orl %ecx, %eax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movswl 0x2b8(%rax), %eax
movswl -0xa(%rbp), %ecx
cmpl %ecx, %eax
je 0x1b45
movq -0x8(%rbp), %rax
cmpw $0x0, 0x2b8(%rax)
je 0x1b05
movq -0x8(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x10b0
movq -0x8(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
movq -0x8(%rbp), %rax
movl 0x1cc(%rax), %esi
movw -0xa(%rbp), %ax
movq -0x8(%rbp), %r8
leaq 0x187(%rip), %rcx       # 0x1cb0
movswl %ax, %edx
callq 0x11c0
movq -0x8(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
xorl %eax, %eax
movl %eax, %esi
callq 0x1140
movq -0x8(%rbp), %rax
movswl 0x238(%rax), %eax
movswl -0xc(%rbp), %ecx
cmpl %ecx, %eax
je 0x1bb6
movq -0x8(%rbp), %rax
cmpw $0x0, 0x238(%rax)
je 0x1b76
movq -0x8(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x10b0
movq -0x8(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movq -0x8(%rbp), %rax
movl 0x1c8(%rax), %esi
movw -0xc(%rbp), %ax
movq -0x8(%rbp), %r8
leaq 0x326(%rip), %rcx       # 0x1ec0
movswl %ax, %edx
callq 0x11c0
movq -0x8(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
xorl %eax, %eax
movl %eax, %esi
callq 0x1140
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/obstcp-redir.c
// Function: connection_free
static void
connection_free(struct connection *conn) {
  struct chunk *c, *next;

  if (conn->outevent.ev_events) {
    event_del(&conn->outevent);
  }

  if (conn->obsevent.ev_events) {
    event_del(&conn->obsevent);
  }

  close(conn->fd);
  close(conn->outfd);

  for (c = conn->outqhead; c; c = next) {
    next = c->next;
    free(c);
  }

  for (c = conn->obsqhead; c; c = next) {
    next = c->next;
    free(c);
  }

  obstcp_rbuf_free(&conn->rbuf);

  free(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpw $0x0, 0x2b8(%rax)
je 0x1bea
movq -0x8(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x10b0
movq -0x8(%rbp), %rax
cmpw $0x0, 0x238(%rax)
je 0x1c08
movq -0x8(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x1c8(%rax), %edi
callq 0x1100
movq -0x8(%rbp), %rax
movl 0x1cc(%rax), %edi
callq 0x1100
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1c5a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1c35
movq -0x8(%rbp), %rax
movq 0x2e0(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1c8e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1c69
movq -0x8(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0x5560
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/obstcp-redir.c
// Function: connection_obs_prepare
static void
connection_obs_prepare(struct connection *conn, struct chunk *c) {
  struct iovec iov;

  obstcp_server_encrypt(&conn->ctx, c->data + c->done,
                        c->data + c->done, c->length - c->done);
  obstcp_server_prefix(&conn->ctx, &iov);
  if (iov.iov_len > CHUNK_PRE) abort();
  c->done -= iov.iov_len;
  c->length += iov.iov_len;
  memcpy(c->data + c->done, iov.iov_base, iov.iov_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
addq $0x18, %rdx
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addq %rax, %rdx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %ecx
callq 0x4010
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4090
cmpq $0x40, -0x18(%rbp)
jbe 0x2148
callq 0x1040
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
subq %rdx, %rcx
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1160
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/obstcp-redir.c
// Function: chunk_nq
static void
chunk_nq(struct chunk *c, struct chunk **head, struct chunk **tail) {
  c->last = *tail;
  c->next = NULL;
  *tail = c;
  if (!*head) *head = c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x21da
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/obstcp-redir.c
// Function: connection_obs_write
static int
connection_obs_write(struct connection *conn) {
  struct chunk *c, *next;
  for (c = conn->obsqhead; c; c = next) {
    next = c->next;
    if (!connection_write(c, conn->fd)) {
      connection_free(conn);
      return 0;
    }
    if (c->done == c->length) {
      conn->obsqlen -= c->length;
      chunk_free(&conn->obsqhead, &conn->obsqtail);
    } else {
      break;
    }
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x2e0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2292
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c8(%rax), %esi
callq 0x2380
cmpl $0x0, %eax
jne 0x223b
movq -0x10(%rbp), %rdi
callq 0x1bc0
movl $0x0, -0x4(%rbp)
jmp 0x2299
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x2281
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x304(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x304(%rax)
movq -0x10(%rbp), %rdi
addq $0x2e0, %rdi            # imm = 0x2E0
movq -0x10(%rbp), %rsi
addq $0x2e8, %rsi            # imm = 0x2E8
callq 0x2460
jmp 0x2283
jmp 0x2292
jmp 0x2285
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x21fb
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/agl[P]obstcp/obstcp-redir.c
// Function: connection_out_write
static int
connection_out_write(struct connection *conn) {
  struct chunk *c, *next;
  for (c = conn->outqhead; c; c = next) {
    next = c->next;
    if (!connection_write(c, conn->outfd)) {
      connection_free(conn);
      return 0;
    }
    if (c->done == c->length) {
      conn->outqlen -= c->length;
      chunk_free(&conn->outqhead, &conn->outqtail);
    } else {
      break;
    }
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x2d0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2362
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1cc(%rax), %esi
callq 0x2380
cmpl $0x0, %eax
jne 0x230b
movq -0x10(%rbp), %rdi
callq 0x1bc0
movl $0x0, -0x4(%rbp)
jmp 0x2369
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x2351
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x300(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x300(%rax)
movq -0x10(%rbp), %rdi
addq $0x2d0, %rdi            # imm = 0x2D0
movq -0x10(%rbp), %rsi
addq $0x2d8, %rsi            # imm = 0x2D8
callq 0x2460
jmp 0x2353
jmp 0x2362
jmp 0x2355
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x22cb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)