LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/node.c
// Function: Children
static int Children(lua_State *L)
    {
    unsigned int i;
    node_t *node = checknode(L, 1);
    lua_newtable(L);
    for(i = 0; i < node->mNumChildren; i++)
        {
        pushnode(L, node->mChildren[i]);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x71c8(%rip), %rdx      # 0x173e2
callq 0x6700
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq (%rsp), %rcx
cmpl 0x450(%rcx), %eax
jae 0x1028d
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x458(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x6390
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10239
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/node.c
// Function: Mesh
static int Mesh(lua_State *L)
    {
#define scene ud->scene
    unsigned int index;
    node_t *node = checknode(L, 1);
    unsigned int i = checkindex(L, 2);
    ud_t *ud = userdata(node);
    if(i >= node->mNumMeshes)
        return luaL_argerror(L, 2, "out of range");
    index = node->mMeshes[i];
    if(index >= scene->mNumMeshes)
        return unexpected(L);   
    return pushmesh(L, scene->mMeshes[index]);
#undef scene
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x7128(%rip), %rdx      # 0x173e2
callq 0x6700
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x6320
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x6780
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x460(%rcx), %eax
jb 0x10313
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x5ea1(%rip), %rdx      # 0x161a9
callq 0x61c0
movl %eax, 0x34(%rsp)
jmp 0x10384
movq 0x18(%rsp), %rax
movq 0x468(%rax), %rax
movl 0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x10(%rcx), %eax
jb 0x10361
movq 0x28(%rsp), %rdi
leaq 0x5e6e(%rip), %rsi      # 0x161b6
leaq 0x70e2(%rip), %rdx      # 0x17431
movl $0x8d, %ecx
movb $0x0, %al
callq 0x67b0
movl %eax, 0x34(%rsp)
jmp 0x10384
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
movl 0x24(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x6390
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/node.c
// Function: Meshes
static int Meshes(lua_State *L)
    {
#define scene ud->scene
    unsigned int i, index;
    node_t *node = checknode(L, 1);
    ud_t *ud = userdata(node);
    lua_newtable(L);
    for(i = 0; i < node->mNumMeshes; i++)
        {
        index = node->mMeshes[i];
        if(index >= scene->mNumMeshes)
            return unexpected(L);   
        pushmesh(L, scene->mMeshes[index]);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
#undef scene
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x7038(%rip), %rdx      # 0x173e2
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x6780
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x460(%rcx), %eax
jae 0x10482
movq 0x8(%rsp), %rax
movq 0x468(%rax), %rax
movl 0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq (%rsp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x10(%rcx), %eax
jb 0x1043a
movq 0x18(%rsp), %rdi
leaq 0x5d95(%rip), %rsi      # 0x161b6
leaq 0x7009(%rip), %rdx      # 0x17431
movl $0x7a, %ecx
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0x1048a
movq 0x18(%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
movl 0x10(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x6390
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x103d8
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/nodeanim.c
// Function: NodeName
static int NodeName(lua_State *L)
    {
    nodeanim_t *nodeanim = checknodeanim(L, 1);
    if(nodeanim->mNodeName.length == 0)
        return 0;
    lua_pushstring(L, nodeanim->mNodeName.data);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x6e86(%rip), %rdx      # 0x17460
callq 0x6700
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, (%rax)
jne 0x105f6
movl $0x0, 0x14(%rsp)
jmp 0x10610
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
addq $0x4, %rsi
callq 0x6930
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/nodeanim.c
// Function: PositionKeys
static int PositionKeys(lua_State *L)
/* { key1, key2, ... }
 *
 * key1 = { time = 123.456, value = { x, y, z } }
 */
    {
    unsigned int i;
    nodeanim_t *nodeanim = checknodeanim(L, 1);
    lua_newtable(L);
    for(i = 0; i < nodeanim->mNumPositionKeys; i++)
        {
#define key nodeanim->mPositionKeys[i]
        lua_newtable(L);
        lua_pushnumber(L, key.mTime);
        lua_setfield(L, -2, "time");
        pushvector3(L, &(key.mValue), 1);
        lua_setfield(L, -2, "value");
        lua_rawseti(L, -2, i+1);
#undef key
        }
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x6d36(%rip), %rdx      # 0x17460
callq 0x6700
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq (%rsp), %rcx
cmpl 0x404(%rcx), %eax
jae 0x1080e
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x408(%rax), %rax
movl 0xc(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
callq 0x6500
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x6bf7(%rip), %rdx      # 0x17397
callq 0x62e0
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x408(%rax), %rsi
movl 0xc(%rsp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rsi
addq $0x8, %rsi
movl $0x1, %edx
callq 0x6610
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x6bbd(%rip), %rdx      # 0x1739c
callq 0x62e0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10749
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/nodeanim.c
// Function: RotationKeys
static int RotationKeys(lua_State *L)
/* { key1, key2, ... }
 *
 * key1 = { time = 123.456, value = { w, x, y, z } }
 */
    {
    unsigned int i;
    nodeanim_t *nodeanim = checknodeanim(L, 1);
    lua_newtable(L);
    for(i = 0; i < nodeanim->mNumRotationKeys; i++)
        {
#define key nodeanim->mRotationKeys[i]
        lua_newtable(L);
        lua_pushnumber(L, key.mTime);
        lua_setfield(L, -2, "time");
        pushquaternion(L, &(key.mValue), 1);
        lua_setfield(L, -2, "value");
        lua_rawseti(L, -2, i+1);
#undef key
        }
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x6c26(%rip), %rdx      # 0x17460
callq 0x6700
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq (%rsp), %rcx
cmpl 0x410(%rcx), %eax
jae 0x1091e
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x418(%rax), %rax
movl 0xc(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
callq 0x6500
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x6ae7(%rip), %rdx      # 0x17397
callq 0x62e0
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x418(%rax), %rsi
movl 0xc(%rsp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rsi
addq $0x8, %rsi
movl $0x1, %edx
callq 0x6090
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x6aad(%rip), %rdx      # 0x1739c
callq 0x62e0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10859
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/nodeanim.c
// Function: ScalingKeys
static int ScalingKeys(lua_State *L)
/* { key1, key2, ... }
 *
 * key1 = { time = 123.456, value = { x, y, z } }
 */
    {
    unsigned int i;
    nodeanim_t *nodeanim = checknodeanim(L, 1);
    lua_newtable(L);
    for(i = 0; i < nodeanim->mNumScalingKeys; i++)
        {
#define key nodeanim->mScalingKeys[i]
        lua_newtable(L);
        lua_pushnumber(L, key.mTime);
        lua_setfield(L, -2, "time");
        pushvector3(L, &(key.mValue), 1);
        lua_setfield(L, -2, "value");
        lua_rawseti(L, -2, i+1);
#undef key
        }
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x6b16(%rip), %rdx      # 0x17460
callq 0x6700
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq (%rsp), %rcx
cmpl 0x420(%rcx), %eax
jae 0x10a2e
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x428(%rax), %rax
movl 0xc(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
callq 0x6500
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x69d7(%rip), %rdx      # 0x17397
callq 0x62e0
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x428(%rax), %rsi
movl 0xc(%rsp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rsi
addq $0x8, %rsi
movl $0x1, %edx
callq 0x6610
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x699d(%rip), %rdx      # 0x1739c
callq 0x62e0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10969
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/scene.c
// Function: Mesh
static int Mesh(lua_State *L)
    {
    scene_t *scene = checkscene(L, 1);
    unsigned int i = checkindex(L, 2); /* 1-based */
    if(i > scene->mNumMeshes)
        return luaL_argerror(L, 2, "out of range");
    pushmesh(L, scene->mMeshes[i]);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x5304(%rip), %rdx      # 0x168ee
callq 0x6700
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x6320
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jbe 0x11631
movq 0x18(%rsp), %rdi
movl $0x2, %esi
leaq 0x4b83(%rip), %rdx      # 0x161a9
callq 0x61c0
movl %eax, 0x24(%rsp)
jmp 0x11654
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x6390
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/scene.c
// Function: Meshes
static int Meshes(lua_State *L)
    {
    unsigned int i;
    scene_t *scene = checkscene(L, 1);
    lua_newtable(L);
    for(i = 0; i < scene->mNumMeshes; i++)
        {
        pushmesh(L, scene->mMeshes[i]);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x5274(%rip), %rdx      # 0x168ee
callq 0x6700
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq (%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x116e7
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x6390
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x11699
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/texture.c
// Function: moonassimp_newtexture
int newtexture(lua_State *L, scene_t *scene, texture_t *texture)
    {
    ud_t *ud;
    TRACE_CREATE(texture, "texture");
    ud = newuserdata(L, (void*)texture, TEXTURE_MT);
    ud->scene = scene;
    return 1;   
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rsi
leaq 0x5962(%rip), %rdi      # 0x175c1
movb $0x0, %al
callq 0x6720
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x595f(%rip), %rdx      # 0x175d6
callq 0x68d0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/texture.c
// Function: Width
static int Width(lua_State *L)
    {
    texture_t *texture = checktexture(L, 1);
    if(Compressed(texture)) return 0;
    lua_pushinteger(L, texture->mWidth);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x584c(%rip), %rdx      # 0x175d6
callq 0x6700
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x11da7
movl $0x0, 0x14(%rsp)
jmp 0x11dc1
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x6310
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/texture.c
// Function: Height
static int Height(lua_State *L)
    {
    texture_t *texture = checktexture(L, 1);
    if(Compressed(texture)) return 0;
    lua_pushinteger(L, texture->mHeight);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x57ec(%rip), %rdx      # 0x175d6
callq 0x6700
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x11e07
movl $0x0, 0x14(%rsp)
jmp 0x11e22
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x6310
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/texture.c
// Function: FormatHint
static int FormatHint(lua_State *L)
    {
    texture_t *texture = checktexture(L, 1);
    if(!Compressed(texture)) return 0;
    lua_pushstring(L, texture->achFormatHint);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x578c(%rip), %rdx      # 0x175d6
callq 0x6700
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x4(%rax)
je 0x11e67
movl $0x0, 0x14(%rsp)
jmp 0x11e81
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
addq $0x8, %rsi
callq 0x6930
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/texture.c
// Function: Data
static int Data(lua_State *L)
/* returns data as a binary string */
    {
    size_t len;
    texture_t *texture = checktexture(L, 1);
    if(!Compressed(texture)) return 0;
    len = texture->mWidth;
    lua_pushlstring(L, (char*)(texture->pcData), len);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x56ac(%rip), %rdx      # 0x175d6
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rax)
je 0x11f49
movl $0x0, 0x24(%rsp)
jmp 0x11f75
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x6680
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/texture.c
// Function: Size
static int Size(lua_State *L)
/* size = texture:size() */
    {
    texture_t *texture = checktexture(L, 1);
    if(!Compressed(texture)) return 0;
    lua_pushinteger(L, texture->mWidth);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x563c(%rip), %rdx      # 0x175d6
callq 0x6700
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x4(%rax)
je 0x11fb7
movl $0x0, 0x14(%rsp)
jmp 0x11fd1
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x6310
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/texture.c
// Function: Texel_
static int Texel_(lua_State *L, int asfloat)
    {
    unsigned int u, v, i;
    texture_t *texture = checktexture(L, 1);
    if(Compressed(texture)) return 0;
    u = checkindex(L, 2);
    v = checkindex(L, 3);
    if(u >= texture->mWidth)
        return luaL_argerror(L, 2, "out of range");
    if(v >= texture->mHeight)
        return luaL_argerror(L, 3, "out of range");
    i =  v * texture->mWidth + u; /* texel index */
    if(asfloat)
        return pushtexelf(L, &(texture->pcData[i]), 0);
    return pushtexel(L, &(texture->pcData[i]), 0);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x55d8(%rip), %rdx      # 0x175d6
callq 0x6700
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x1201e
movl $0x0, 0x24(%rsp)
jmp 0x120fa
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x6320
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x6320
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
movq (%rsp), %rcx
cmpl (%rcx), %eax
jb 0x1206f
movq 0x18(%rsp), %rdi
movl $0x2, %esi
leaq 0x4148(%rip), %rdx      # 0x161a9
callq 0x61c0
movl %eax, 0x24(%rsp)
jmp 0x120fa
movl 0xc(%rsp), %eax
movq (%rsp), %rcx
cmpl 0x4(%rcx), %eax
jb 0x12098
movq 0x18(%rsp), %rdi
movl $0x3, %esi
leaq 0x411c(%rip), %rdx      # 0x161a9
callq 0x61c0
movl %eax, 0x24(%rsp)
jmp 0x120fa
movl 0xc(%rsp), %eax
movq (%rsp), %rcx
imull (%rcx), %eax
addl 0x10(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x120d7
movq 0x18(%rsp), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
movl 0x8(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rsi
xorl %edx, %edx
callq 0x69d0
movl %eax, 0x24(%rsp)
jmp 0x120fa
movq 0x18(%rsp), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
movl 0x8(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rsi
xorl %edx, %edx
callq 0x69d8
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/texture.c
// Function: Texels_
static int Texels_(lua_State *L, int asfloat)
/* returns a W*H matrix (table) of textels (4-value tables) */
    {
#define W texture->mWidth
#define H texture->mHeight
    unsigned int u, v, i;
    int (*push)(lua_State*L, texel_t*, int) = (asfloat==0) ? pushtexel : pushtexelf;
    texture_t *texture = checktexture(L, 1);
    if(Compressed(texture)) return 0;
    lua_newtable(L);
    for(v = 0; v < H; v++)
        {
        lua_newtable(L); /* v-th row */
        for(u = 0; u < W; u++)
            {
            i =  v*W + u; /* texel index */
            push(L, &(texture->pcData[i]), 1); /* u-th texel in the v-th row */
            lua_rawseti(L, -2, u+1);
            }
        lua_rawseti(L, -2, v+1);
        }   
    return 1;
#undef W
#undef H
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl 0x24(%rsp), %edx
movq 0xaea8(%rip), %rax      # 0x1cfd0
movq 0xaeb9(%rip), %rcx      # 0x1cfe8
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x548a(%rip), %rdx      # 0x175d6
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x1216e
movl $0x0, 0x34(%rsp)
jmp 0x1224b
movq 0x28(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x12243
movq 0x28(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x12219
movl 0x1c(%rsp), %eax
movq 0x8(%rsp), %rcx
imull (%rcx), %eax
addl 0x20(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rsi
movl 0x18(%rsp), %ecx
shlq $0x2, %rcx
addq %rcx, %rsi
movl $0x1, %edx
callq *%rax
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x121ac
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x12184
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/udata.c
// Function: moonassimp_udata_unref
int udata_unref(lua_State *L, const void *ptr)
/* unreference udata so that it will be garbage collected */
    {
//  printf("unref object %p\n", ptr);
    udata_t *udata = udata_search((uintptr_t)ptr);
    if(!udata) 
        return luaL_error(L, "invalid object pointer %p", ptr);
    if(udata->ref != LUA_NOREF)
        {
        luaL_unref(L, LUA_REGISTRYINDEX, udata->ref);
        udata->ref = LUA_NOREF;
        }
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x12400
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x124d3
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x51dc(%rip), %rsi      # 0x176a2
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0x12509
movq 0x8(%rsp), %rax
cmpl $-0x2, 0x28(%rax)
je 0x12501
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x28(%rax), %edx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6920
movq 0x8(%rsp), %rax
movl $0xfffffffe, 0x28(%rax) # imm = 0xFFFFFFFE
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/udata.c
// Function: moonassimp_udata_free
int udata_free(lua_State *L, const void *ptr)
/* this should be called in the __gc metamethod
 */
    {
    udata_t *udata = udata_search((uintptr_t)ptr);
//  printf("free object %p\n", ptr);
    if(!udata) 
        return luaL_error(L, "invalid object pointer %p", ptr);
    /* release all references */
    if(udata->ref != LUA_NOREF)
        luaL_unref(L, LUA_REGISTRYINDEX, udata->ref);
    udata_remove(udata);
    free(udata);
    /* mem is released by Lua at garbage collection */
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x12400
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x12563
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x514c(%rip), %rsi      # 0x176a2
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0x125a1
movq 0x8(%rsp), %rax
cmpl $-0x2, 0x28(%rax)
je 0x12585
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x28(%rax), %edx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6920
movq 0x8(%rsp), %rdi
callq 0x125b0
movq 0x8(%rsp), %rdi
callq 0x60a0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/udata.c
// Function: moonassimp_udata_push
int udata_push(lua_State *L, const void *ptr)
    {
    udata_t *udata = udata_search((uintptr_t)ptr);
//  printf("push object %p\n", ptr);
    if(!udata) 
        return luaL_error(L, "invalid object pointer %p", ptr);
    if(udata->ref == LUA_NOREF)
        return luaL_error(L, "unreferenced object");
    if(lua_rawgeti(L, LUA_REGISTRYINDEX, udata->ref) != LUA_TUSERDATA)
        return luaL_error(L, UNEXPECTED_ERROR);
    return 1; /* one value pushed */
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x12400
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x12613
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x509c(%rip), %rsi      # 0x176a2
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0x12681
movq 0x8(%rsp), %rax
cmpl $-0x2, 0x28(%rax)
jne 0x12637
movq 0x18(%rsp), %rdi
leaq 0x5092(%rip), %rsi      # 0x176bc
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0x12681
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq 0x28(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x62b0
cmpl $0x7, %eax
je 0x12679
movq 0x18(%rsp), %rdi
leaq 0x3b56(%rip), %rsi      # 0x161b6
leaq 0x5069(%rip), %rdx      # 0x176d0
movl $0xa3, %ecx
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0x12681
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/udata.c
// Function: moonassimp_udata_free_all
void udata_free_all(void)
/* free all without unreferencing (for atexit()) */
    {
    udata_t *udata;
    while((udata = udata_first(0)))
        {
        udata_remove(udata);
        free(udata);
        }
    }

// Assembly:
pushq %rax
xorl %eax, %eax
movl %eax, %edi
callq 0x126c0
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x126b8
movq (%rsp), %rdi
callq 0x125b0
movq (%rsp), %rdi
callq 0x60a0
jmp 0x12691
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_trace
int trace(const char *fmt, ...)
    {
    va_list args;
    if(!trace_enabled)
        return 0;
    if(fmt)
        {
        va_start(args,fmt);
        vprintf(fmt,args);
        va_end(args);
        }
    return 0;
    }

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0x13d9c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xc8(%rsp)
movq 0x9204(%rip), %rax      # 0x1cfc8
cmpl $0x0, (%rax)
jne 0x13dd6
movl $0x0, 0xd4(%rsp)
jmp 0x13e31
cmpq $0x0, 0xc8(%rsp)
je 0x13e26
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xc8(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x6630
leaq 0xb0(%rsp), %rax
movl $0x0, 0xd4(%rsp)
movl 0xd4(%rsp), %eax
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_checkindex
int checkindex(lua_State *L, int arg)
    {
    int val = luaL_checkinteger(L, arg);
    if(val < 1)
        return luaL_argerror(L, arg, "positive integer expected");
    return val - 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x6440
movl %eax, (%rsp)
cmpl $0x1, (%rsp)
jge 0x141cf
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
leaq 0x35c1(%rip), %rdx      # 0x17785
callq 0x61c0
movl %eax, 0x14(%rsp)
jmp 0x141d9
movl (%rsp), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_optindex
int optindex(lua_State *L, int arg, int optval /* 0-based */)
    {
    int val = luaL_optinteger(L, arg, optval + 1);
    if(val < 1)
        return luaL_argerror(L, arg, "positive integer expected");
    return val - 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x6550
movl %eax, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
jge 0x1423f
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x3551(%rip), %rdx      # 0x17785
callq 0x61c0
movl %eax, 0x24(%rsp)
jmp 0x1424a
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_pushvector2
int pushvector2(lua_State *L, vector2_t *vec, int astable)
    {
    if(astable)
        {
        lua_newtable(L);
        lua_pushnumber(L, vec->x); lua_seti(L, -2, 1);
        lua_pushnumber(L, vec->y); lua_seti(L, -2, 2);
        return 1;
        }
    lua_pushnumber(L, vec->x);  
    lua_pushnumber(L, vec->y);  
    return 2;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x14318
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x63f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x63f0
movl $0x1, 0x24(%rsp)
jmp 0x1434f
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movl $0x2, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_pushvector3
int pushvector3(lua_State *L, vector3_t *vec, int astable)
    {
    if(astable)
        {
        lua_newtable(L);
        lua_pushnumber(L, vec->x); lua_seti(L, -2, 1);
        lua_pushnumber(L, vec->y); lua_seti(L, -2, 2);
        lua_pushnumber(L, vec->z); lua_seti(L, -2, 3);
        return 1;
        }
    lua_pushnumber(L, vec->x);  
    lua_pushnumber(L, vec->y);  
    lua_pushnumber(L, vec->z);  
    return 3;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x14418
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x63f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x63f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x3, %edx
callq 0x63f0
movl $0x1, 0x24(%rsp)
jmp 0x14467
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movl $0x3, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_pushcolor4
int pushcolor4(lua_State *L, color4_t *col, int astable)
    {
    if(astable)
        {
        lua_newtable(L);
        lua_pushnumber(L, col->r); lua_seti(L, -2, 1);
        lua_pushnumber(L, col->g); lua_seti(L, -2, 2);
        lua_pushnumber(L, col->b); lua_seti(L, -2, 3);
        lua_pushnumber(L, col->a); lua_seti(L, -2, 4);
        return 1;
        }
    lua_pushnumber(L, col->r);  
    lua_pushnumber(L, col->g);  
    lua_pushnumber(L, col->b);  
    lua_pushnumber(L, col->a);  
    return 4;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x14664
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x63f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x63f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x3, %edx
callq 0x63f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss 0xc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x4, %edx
callq 0x63f0
movl $0x1, 0x24(%rsp)
jmp 0x146cb
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movss 0xc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movl $0x4, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_pushtexel
int pushtexel(lua_State *L, texel_t *vec, int astable)
    {
    if(astable)
        {
        lua_newtable(L);
        lua_pushinteger(L, vec->r); lua_seti(L, -2, 1);
        lua_pushinteger(L, vec->g); lua_seti(L, -2, 2);
        lua_pushinteger(L, vec->b); lua_seti(L, -2, 3);
        lua_pushinteger(L, vec->a); lua_seti(L, -2, 4);
        return 1;
        }
    lua_pushinteger(L, vec->r); 
    lua_pushinteger(L, vec->g); 
    lua_pushinteger(L, vec->b); 
    lua_pushinteger(L, vec->a); 
    return 4;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x14918
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
movl %eax, %esi
callq 0x6310
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x63f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x1(%rax), %eax
movl %eax, %esi
callq 0x6310
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x63f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %esi
callq 0x6310
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x3, %edx
callq 0x63f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x3(%rax), %eax
movl %eax, %esi
callq 0x6310
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x4, %edx
callq 0x63f0
movl $0x1, 0x24(%rsp)
jmp 0x14973
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
movl %eax, %esi
callq 0x6310
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x1(%rax), %eax
movl %eax, %esi
callq 0x6310
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %esi
callq 0x6310
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x3(%rax), %eax
movl %eax, %esi
callq 0x6310
movl $0x4, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_pushtexelf
int pushtexelf(lua_State *L, texel_t *vec, int astable)
    {
    if(astable)
        {
        lua_newtable(L);
        lua_pushnumber(L, vec->r/255.f); lua_seti(L, -2, 1);
        lua_pushnumber(L, vec->g/255.f); lua_seti(L, -2, 2);
        lua_pushnumber(L, vec->b/255.f); lua_seti(L, -2, 3);
        lua_pushnumber(L, vec->a/255.f); lua_seti(L, -2, 4);
        return 1;
        }
    lua_pushnumber(L, vec->r/255.f);    
    lua_pushnumber(L, vec->g/255.f);    
    lua_pushnumber(L, vec->b/255.f);    
    lua_pushnumber(L, vec->a/255.f);    
    return 4;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x14aa3
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
cvtsi2ss %eax, %xmm0
movss 0x2d53(%rip), %xmm1     # 0x17718
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x63f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x1(%rax), %eax
cvtsi2ss %eax, %xmm0
movss 0x2d18(%rip), %xmm1     # 0x17718
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x63f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cvtsi2ss %eax, %xmm0
movss 0x2cde(%rip), %xmm1     # 0x17718
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x3, %edx
callq 0x63f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x3(%rax), %eax
cvtsi2ss %eax, %xmm0
movss 0x2ca3(%rip), %xmm1     # 0x17718
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x4, %edx
callq 0x63f0
movl $0x1, 0x24(%rsp)
jmp 0x14b46
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
cvtsi2ss %eax, %xmm0
movss 0x2c5b(%rip), %xmm1     # 0x17718
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x1(%rax), %eax
cvtsi2ss %eax, %xmm0
movss 0x2c34(%rip), %xmm1     # 0x17718
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cvtsi2ss %eax, %xmm0
movss 0x2c0e(%rip), %xmm1     # 0x17718
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x3(%rax), %eax
cvtsi2ss %eax, %xmm0
movss 0x2be7(%rip), %xmm1     # 0x17718
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movl $0x4, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_newuserdata
ud_t *newuserdata(lua_State *L, void *ptr, const char *mt)
    {
    ud_t *ud;
    ud = (ud_t*)udata_new(L, sizeof(ud_t), ptr, mt);
    memset(ud, 0, sizeof(ud_t));
    ud->obj = ptr ? ptr : (void*)ud;
    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 $0x30, %esi
callq 0x6280
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x6300
cmpq $0x0, 0x18(%rsp)
je 0x15455
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
jmp 0x1545e
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x1, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_freeuserdata
int freeuserdata(lua_State *L, void *ptr)
    {
    ud_t *ud = userdata(ptr);
    if(!ud || !IsValid(ud))
        return 0; /* already deleted */
    CancelValid(ud);
    udata_free(L, ptr);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x6780
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x154c5
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x1, %eax
je 0x154cf
movl $0x0, 0x24(%rsp)
jmp 0x154fb
jmp 0x154d1
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
andl $-0x2, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x62c0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_testxxx
void* testxxx(lua_State *L, int arg, const char *mt)
    {
    ud_t *ud = (ud_t*)udata_test(L, arg, mt);
    if(ud && IsValid(ud))
        return ud->obj;
    return NULL;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x6740
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x1555d
movq (%rsp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x1555d
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x15566
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_checkxxx
void* checkxxx(lua_State *L, int arg, const char *mt)
    {
    void *p = testxxx(L, arg, mt);
    if(p) return p;
    lua_pushfstring(L, "not a %s", mt);
    luaL_argerror(L, arg, lua_tostring(L, -1));
    return NULL;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0x65c0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x155ae
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x15603
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x21e0(%rip), %rsi      # 0x1779f
movb $0x0, %al
callq 0x63e0
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x61e0
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movq %rax, %rdx
callq 0x61c0
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_3/3.6/zombie.c
// Function: main
int main ()
	{
	pid_t child_pid;
	/* Create a child process. */
	child_pid = fork ();
	if (child_pid > 0) {
		/* This is the parent process. Sleep for a minute. */
		sleep (60);
	}
	else {
		/* This is the child process. Exit immediately. */
		exit (0);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1030
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x1189
movl $0x3c, %edi
callq 0x1040
jmp 0x1190
xorl %edi, %edi
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/evilwombat[P]gopro-fw-tools/h3-wifi-address.c
// Function: print_usage
static void print_usage(const char *name)
{
	printf("Usage: %s [firmware file] [address digit] [output filename]\n", name);

	printf("Patch Gopro Wifi Firmware with custom IP address\n");
	printf("New camera address will be 10.X.5.9\n");
	printf("New computer address will be 10.X.5.109\n");
	printf("Where X is the address digit specified\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xdfe(%rip), %rdi       # 0x2525
movb $0x0, %al
callq 0x1060
leaq 0xe2d(%rip), %rdi       # 0x2562
movb $0x0, %al
callq 0x1060
leaq 0xe51(%rip), %rdi       # 0x2594
movb $0x0, %al
callq 0x1060
leaq 0xe68(%rip), %rdi       # 0x25b9
movb $0x0, %al
callq 0x1060
leaq 0xe83(%rip), %rdi       # 0x25e2
movb $0x0, %al
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/evilwombat[P]gopro-fw-tools/h3-wifi-address.c
// Function: read_word
static uint32_t read_word(unsigned char *buf, int offset)
{
	return (buf[offset] << 24) |
	       (buf[offset+1] << 16) |
	       (buf[offset+2] << 8) |
	       (buf[offset+3]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl $0x3, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/evilwombat[P]gopro-fw-tools/h3-wifi-address.c
// Function: write_word
static void write_word(unsigned char *buf, int offset, uint32_t word)
{
	buf[offset] = word >> 24;
	buf[offset+1] = word >> 16;
	buf[offset+2] = word >> 8;
	buf[offset+3] = word;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
shrl $0x18, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
shrl $0x10, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/evilwombat[P]gopro-fw-tools/h3-wifi-address.c
// Function: patch_buffer
static int patch_buffer(unsigned char *buf, int *offsets, unsigned char val, unsigned char old_val)
{
	int i;

	for (i = 0; offsets[i] != -1; i++) {
		if (buf[offsets[i]] != old_val) {
			printf("Patching mismatch at offset %08x, expected %02x, got %02x\n",
			       offsets[i], old_val, buf[offsets[i]]);
			return -1;
		}

		buf[offsets[i]] = val;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x1939
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movzbl (%rax,%rcx), %eax
movzbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
je 0x1915
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movzbl -0x1a(%rbp), %edx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdi
movslq (%rcx,%rdi,4), %rcx
movzbl (%rax,%rcx), %ecx
leaq 0xd05(%rip), %rdi       # 0x260a
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1940
movb -0x19(%rbp), %dl
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x18b1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)