LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rongarret[P]clmm/utils.c
// Function: b64decode
p_vector b64decode(c_string input, size_t padding) {
  size_t bytecnt_estimate = Base64decode_len(input);
  p_vector v = mkvector(bytecnt_estimate, padding);
  size_t bytecnt = Base64decode((char *)v->data, input);
  if ((bytecnt > bytecnt_estimate) || (bytecnt < bytecnt_estimate-3)) {
    die("Failed to decode base64 string");
  }
  v->size = bytecnt;
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a30
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1750
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x1aa0
cltq
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x1a02
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x3, %rcx
cmpq %rcx, %rax
jae 0x1a0e
leaq 0x471e(%rip), %rdi      # 0x6127
callq 0x1670
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rongarret[P]clmm/base64.c
// Function: Base64decode_len
int Base64decode_len(const char *bufcoded)
{
    int nbytesdecoded;
    register const unsigned char *bufin;
    register int nprbytes;

    bufin = (const unsigned char *) bufcoded;
    while (pr2six[*(bufin++)] <= 63);

    nprbytes = (bufin - (const unsigned char *) bufcoded) - 1;
    nbytesdecoded = ((nprbytes + 3) / 4) * 3;

    return nbytesdecoded + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x46f5(%rip), %rax      # 0x6150
movzbl (%rax,%rcx), %eax
cmpl $0x3f, %eax
jg 0x1a66
jmp 0x1a40
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x3, %eax
movl $0x4, %ecx
cltd
idivl %ecx
imull $0x3, %eax, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/box.c
// Function: moonglmath_testbox
int testbox(lua_State *L, int arg, box_t b, size_t *dim)
/* Tests if the element at arg is a box and sets b and *dim accordingly
 * (unless they are passed as 0).
 */
    {
    size_t i;
    size_t dim_;
    if(!testmetatable(L, arg, BOX_MT)) return 0;

    lua_getfield(L, arg, "dimensions");   
    dim_ = luaL_checkinteger(L, -1);
    lua_pop(L, 1);
    checkboxdim(L, dim_);

    if(dim != NULL) *dim = dim_;
    if(b != NULL)
        {
        box_clear(b);
        for(i=0; i < 2*dim_; i++)
            {
            lua_geti(L, arg, i+1);
            b[i] = luaL_checknumber(L, -1);
            lua_pop(L, 1);
            }
        }
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
leaq 0x1a009(%rip), %rdx     # 0x23000
callq 0x8180
cmpl $0x0, %eax
jne 0x900e
movl $0x0, 0x34(%rsp)
jmp 0x911a
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
leaq 0x19ffd(%rip), %rdx     # 0x2301b
callq 0x8e80
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8740
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
cmpq $0x2, (%rsp)
jb 0x9053
cmpq $0x3, (%rsp)
jbe 0x906f
movq 0x28(%rsp), %rdi
leaq 0x19fb0(%rip), %rsi     # 0x2300f
movb $0x0, %al
callq 0x8b30
movl %eax, 0x34(%rsp)
jmp 0x911a
jmp 0x9071
cmpq $0x0, 0x10(%rsp)
je 0x9085
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x18(%rsp)
je 0x9112
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x8530
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
shlq %rcx
cmpq %rcx, %rax
jae 0x9110
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x8(%rsp), %rdx
addq $0x1, %rdx
callq 0x8e10
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8350
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x90ab
jmp 0x9112
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]moonglmath/src/box.c
// Function: moonglmath_pushbox
int pushbox(lua_State *L, box_t b, size_t dim)
/* dim = 2 or 3
 */
    {
    size_t i;
    checkboxdim(L, dim);
    lua_newtable(L);
    setmetatable(L, BOX_MT);
    for(i=0; i<2*dim; i++)
        {
        lua_pushnumber(L, b[i]);
        lua_seti(L, -2, i+1);
        }
    lua_pushinteger(L, dim);
    lua_setfield(L, -2, "dimensions");
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x2, 0x8(%rsp)
jb 0x91e3
cmpq $0x3, 0x8(%rsp)
jbe 0x91ff
movq 0x18(%rsp), %rdi
leaq 0x19e20(%rip), %rsi     # 0x2300f
movb $0x0, %al
callq 0x8b30
movl %eax, 0x24(%rsp)
jmp 0x92a3
jmp 0x9201
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8320
movq 0x18(%rsp), %rdi
leaq 0x19de5(%rip), %rsi     # 0x23000
callq 0x89f0
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
shlq %rcx
cmpq %rcx, %rax
jae 0x9276
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x8840
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
addq $0x1, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x86a0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x9228
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x8540
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x19d85(%rip), %rdx     # 0x2301b
callq 0x84e0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/box.c
// Function: Concat
static int Concat(lua_State *L)
    {
    box_t b;
    size_t dim;
    if(testbox(L, 1, b, &dim))
        {
        ToString_(L, b, dim);
        lua_pushvalue(L, 2);
        }
    else if(testbox(L, 2, b, &dim))
        {
        lua_pushvalue(L, 1);
        ToString_(L, b, dim);
        }
    else 
        return unexpected(L);
    lua_concat(L, 2);
    return 1;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
leaq 0x8(%rsp), %rcx
callq 0x8bf0
cmpl $0x0, %eax
je 0x938c
movq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x9420
movq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0x8650
jmp 0x93f6
movq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x2, %esi
leaq 0x8(%rsp), %rcx
callq 0x8bf0
cmpl $0x0, %eax
je 0x93cf
movq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x8650
movq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x9420
jmp 0x93f4
movq 0x58(%rsp), %rdi
leaq 0x19c99(%rip), %rsi     # 0x23074
leaq 0x19cac(%rip), %rdx     # 0x2308e
movl $0xb9, %ecx
movb $0x0, %al
callq 0x8b30
movl %eax, 0x64(%rsp)
jmp 0x940d
jmp 0x93f6
movq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0x8ca0
movl $0x1, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/box.c
// Function: ToString_
static int ToString_(lua_State *L, box_t b, size_t dim)
/* With snprintf because lua_pushfstring does not support the %g conversion specifier */
    {
#define SZ 512
#define space (SZ-p)
    char str[SZ];
    int p=0;
    switch(dim)
        {
        case 2: p = snprintf(str, space, "[ "FMT", "FMT", "FMT", "FMT" ]", 
                                                b[0], b[1], b[2], b[3]); break;
        case 3: p = snprintf(str, space, "[ "FMT", "FMT", "FMT", "FMT", "FMT", "FMT" ]", 
                                                b[0], b[1], b[2], b[3], b[4], b[5]); break;
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    if(space<0)
        { 
        /* truncate */
        p = SZ - 5; 
        p+=snprintf(str+p, space, " ...");
        lua_pushlstring(L, str, p);
        return 1;
        }
    lua_pushlstring(L, str, p);
    return 1;
#undef space
#undef SZ
    }

// Assembly:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x228(%rsp)
movq %rsi, 0x220(%rsp)
movq %rdx, 0x218(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x218(%rsp), %rax
movq %rax, (%rsp)
subq $0x2, %rax
je 0x946a
jmp 0x945b
movq (%rsp), %rax
subq $0x3, %rax
je 0x94c5
jmp 0x9537
leaq 0x10(%rsp), %rdi
movl $0x200, %eax            # imm = 0x200
subl 0xc(%rsp), %eax
movslq %eax, %rsi
movq 0x220(%rsp), %rax
movsd (%rax), %xmm0
movq 0x220(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq 0x220(%rsp), %rax
movsd 0x10(%rax), %xmm2
movq 0x220(%rsp), %rax
movsd 0x18(%rax), %xmm3
leaq 0x19b91(%rip), %rdx     # 0x23046
movb $0x4, %al
callq 0x8420
movl %eax, 0xc(%rsp)
jmp 0x9565
leaq 0x10(%rsp), %rdi
movl $0x200, %eax            # imm = 0x200
subl 0xc(%rsp), %eax
movslq %eax, %rsi
movq 0x220(%rsp), %rax
movsd (%rax), %xmm0
movq 0x220(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq 0x220(%rsp), %rax
movsd 0x10(%rax), %xmm2
movq 0x220(%rsp), %rax
movsd 0x18(%rax), %xmm3
movq 0x220(%rsp), %rax
movsd 0x20(%rax), %xmm4
movq 0x220(%rsp), %rax
movsd 0x28(%rax), %xmm5
leaq 0x19b2f(%rip), %rdx     # 0x23059
movb $0x6, %al
callq 0x8420
movl %eax, 0xc(%rsp)
jmp 0x9565
movq 0x228(%rsp), %rdi
leaq 0x19b2e(%rip), %rsi     # 0x23074
leaq 0x19b41(%rip), %rdx     # 0x2308e
movl $0x91, %ecx
movb $0x0, %al
callq 0x8b30
movl %eax, 0x234(%rsp)
jmp 0x95f0
movl $0x200, %eax            # imm = 0x200
subl 0xc(%rsp), %eax
cmpl $0x0, %eax
jge 0x95ce
movl $0x1fb, 0xc(%rsp)       # imm = 0x1FB
leaq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rax
addq %rax, %rdi
movl $0x200, %eax            # imm = 0x200
subl 0xc(%rsp), %eax
movslq %eax, %rsi
leaq 0x19af9(%rip), %rdx     # 0x23094
movb $0x0, %al
callq 0x8420
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x228(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rdx
callq 0x8a00
movl $0x1, 0x234(%rsp)
jmp 0x95f0
movq 0x228(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rdx
callq 0x8a00
movl $0x1, 0x234(%rsp)
movl 0x234(%rsp), %eax
addq $0x238, %rsp            # imm = 0x238
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/box.c
// Function: Box
static int Box(lua_State *L, size_t dim)
/* creates a box of dimensions 'dim', from a box or a list of values 
 * the size is adapted by discarding exceeding values or adding zeros
 * in lieu of missing values.
 * boxN(b)
 * boxN([x1 ,[x2,...[,x2N]]])
 */
    {
    box_t b;
    size_t bdim, i, arg;
    arg = 1;
    if(testbox(L, arg, b, &bdim))
        return pushbox(L, b, bdim);
    checkboxdim(L, dim);
    for(i = 0; i < 2*dim; i++)
        b[i] = luaL_optnumber(L, arg++, 0);
    return pushbox(L, b, dim);
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq $0x1, 0x8(%rsp)
movq 0x68(%rsp), %rdi
movq 0x8(%rsp), %rax
movl %eax, %esi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x8bf0
cmpl $0x0, %eax
je 0x96d4
movq 0x68(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x8e00
movl %eax, 0x74(%rsp)
jmp 0x976f
jmp 0x96d6
cmpq $0x2, 0x60(%rsp)
jb 0x96e6
cmpq $0x3, 0x60(%rsp)
jbe 0x96ff
movq 0x68(%rsp), %rdi
leaq 0x1991d(%rip), %rsi     # 0x2300f
movb $0x0, %al
callq 0x8b30
movl %eax, 0x74(%rsp)
jmp 0x976f
jmp 0x9701
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x60(%rsp), %rcx
shlq %rcx
cmpq %rcx, %rax
jae 0x9757
movq 0x68(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movl %eax, %esi
xorps %xmm0, %xmm0
callq 0x8370
movq 0x10(%rsp), %rax
movsd %xmm0, 0x20(%rsp,%rax,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x970a
movq 0x68(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x8e00
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/box.c
// Function: IsBox
static int IsBox(lua_State *L, size_t dim)
    {
    size_t bdim;
    if(!testbox(L, 1, NULL, &bdim))
        lua_pushboolean(L, 0);
    else
        lua_pushboolean(L, (bdim==dim));
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
movq %rsp, %rcx
callq 0x8bf0
cmpl $0x0, %eax
jne 0x97b7
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x8890
jmp 0x97d2
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x8890
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/complex.c
// Function: moonglmath_testcomplex
int testcomplex(lua_State *L, int arg, complex_t *z)
/* Tests if the element at arg is a complex number and sets z accordingly
 * (unless it is passed as 0).
 * Accepts also a real number x, in which case z = x+I*0;
 */
    {
    double x, y;
    if(lua_isnumber(L, arg))
        {
        if(z != NULL)
            *z = lua_tonumber(L, arg);
        return 1;
        }

    if(!testmetatable(L, arg, COMPLEX_MT)) return 0;

    if(z != NULL)
        {
        lua_geti(L, arg, 1);
        x = luaL_checknumber(L, -1);
        lua_pop(L, 1);
        lua_geti(L, arg, 2);
        y = luaL_checknumber(L, -1);
        lua_pop(L, 1);
        *z = x + I*y;
        }
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x983d
cmpq $0x0, 0x18(%rsp)
je 0x9830
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8680
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movl $0x1, 0x34(%rsp)
jmp 0x9917
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
leaq 0x1987b(%rip), %rdx     # 0x230c8
callq 0x8180
cmpl $0x0, %eax
jne 0x9864
movl $0x0, 0x34(%rsp)
jmp 0x9917
cmpq $0x0, 0x18(%rsp)
je 0x990f
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x1, %edx
callq 0x8e10
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8350
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x2, %edx
callq 0x8e10
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8350
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm3
xorps %xmm2, %xmm2
mulsd %xmm3, %xmm2
movsd 0x197c7(%rip), %xmm0    # 0x230c0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm1
movq 0x18(%rsp), %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/complex.c
// Function: moonglmath_pushcomplex
int pushcomplex(lua_State *L, complex_t z)
    {
    lua_newtable(L);
    setmetatable(L, COMPLEX_MT);
    lua_pushnumber(L, creal(z));
    lua_seti(L, -2, 1);
    lua_pushnumber(L, cimag(z));
    lua_seti(L, -2, 2);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movq %rdi, (%rsp)
movq (%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8320
movq (%rsp), %rdi
leaq 0x196fc(%rip), %rsi     # 0x230c8
callq 0x89f0
movq (%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x8840
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x86a0
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x8840
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x86a0
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/complex.c
// Function: moonglmath_complex_Parts
int complex_Parts(lua_State *L)
    {
    complex_t z; 
    checkcomplex(L, 1, &z);
    lua_pushnumber(L, creal(z));
    lua_pushnumber(L, cimag(z));
    return 2;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movq %rsp, %rdx
callq 0x88a0
movq 0x10(%rsp), %rdi
movsd (%rsp), %xmm0
callq 0x8840
movq 0x10(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x8840
movl $0x2, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/complex.c
// Function: Concat
static int Concat(lua_State *L)
    {
    complex_t z;
    if(testcomplex(L, 1, &z))
        {
        ToString_(L, z);
        lua_pushvalue(L, 2);
        }
    else if(testcomplex(L, 2, &z))
        {
        lua_pushvalue(L, 1);
        ToString_(L, z);
        }
    else 
        return unexpected(L);
    lua_concat(L, 2);
    return 1;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
callq 0x8c00
cmpl $0x0, %eax
je 0x9de1
movq 0x38(%rsp), %rdi
movsd 0x28(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0xa270
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x8650
jmp 0x9e60
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x28(%rsp), %rdx
callq 0x8c00
cmpl $0x0, %eax
je 0x9e39
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x8650
movq 0x38(%rsp), %rdi
movsd 0x28(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0xa270
jmp 0x9e5e
movq 0x38(%rsp), %rdi
leaq 0x1922f(%rip), %rsi     # 0x23074
leaq 0x192c0(%rip), %rdx     # 0x2310c
movl $0xb8, %ecx
movb $0x0, %al
callq 0x8b30
movl %eax, 0x44(%rsp)
jmp 0x9e77
jmp 0x9e60
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x8ca0
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/complex.c
// Function: ToString_
static int ToString_(lua_State *L, complex_t z)
/* With snprintf because lua_pushfstring does not support the %g conversion specifier */
    {
#define SZ 512
#define space (SZ-p)
    char str[SZ];
    int p=0;
    if(cimag(z)>=0)
        p = snprintf(str, space, ""FMT"+"FMT"i", creal(z), cimag(z));
    else
        p = snprintf(str, space, ""FMT""FMT"i", creal(z), cimag(z));
    lua_pushlstring(L, str, p);
    return 1;
#undef space
#undef SZ
    }

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movsd %xmm0, 0x218(%rsp)
movsd %xmm1, 0x220(%rsp)
movq %rdi, 0x210(%rsp)
movl $0x0, 0xc(%rsp)
movsd 0x220(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xa2e2
leaq 0x10(%rsp), %rdi
movl $0x200, %eax            # imm = 0x200
subl 0xc(%rsp), %eax
movslq %eax, %rsi
movsd 0x218(%rsp), %xmm0
movsd 0x220(%rsp), %xmm1
leaq 0x18e2a(%rip), %rdx     # 0x230ff
movb $0x2, %al
callq 0x8420
movl %eax, 0xc(%rsp)
jmp 0xa317
leaq 0x10(%rsp), %rdi
movl $0x200, %eax            # imm = 0x200
subl 0xc(%rsp), %eax
movslq %eax, %rsi
movsd 0x218(%rsp), %xmm0
movsd 0x220(%rsp), %xmm1
leaq 0x18dfa(%rip), %rdx     # 0x23106
movb $0x2, %al
callq 0x8420
movl %eax, 0xc(%rsp)
movq 0x210(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rdx
callq 0x8a00
movl $0x1, %eax
addq $0x228, %rsp            # imm = 0x228
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/complex.c
// Function: Complex
static int Complex(lua_State *L)
/* creates a complex number from another on or from its real and imag parts
 * complex()      --> 0+0i
 * complex(x, y)  --> x+yi
 * complex(z)     --> z
 * complex({x1, y1, x2, y2, ...}) --> {z1, z2, ...}
 */
    {
    complex_t z;
    double x, y;
    int t = lua_type(L, 1);

    if((t == LUA_TNONE)||(t == LUA_TNIL)||(t == LUA_TNUMBER))
        {
        x = luaL_optnumber(L, 1, 0);
        y = luaL_optnumber(L, 2, 0);
        z = x + I*y;
        }
    else if(t == LUA_TTABLE && !testmetatable(L, 1, COMPLEX_MT))
        return ComplexArray(L);
    else
        checkcomplex(L, 1, &z);
    return pushcomplex(L, z);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x8d20
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
je 0xac61
cmpl $0x0, 0x14(%rsp)
je 0xac61
cmpl $0x3, 0x14(%rsp)
jne 0xacc2
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorps %xmm0, %xmm0
callq 0x8370
movsd %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
xorps %xmm0, %xmm0
callq 0x8370
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm3
xorps %xmm2, %xmm2
mulsd %xmm3, %xmm2
movsd 0x18414(%rip), %xmm0    # 0x230c0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm1
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x30(%rsp)
jmp 0xad0a
cmpl $0x5, 0x14(%rsp)
jne 0xacf4
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x183ee(%rip), %rdx     # 0x230c8
callq 0x8180
cmpl $0x0, %eax
jne 0xacf4
movq 0x38(%rsp), %rdi
callq 0xad90
movl %eax, 0x44(%rsp)
jmp 0xad3a
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
callq 0x88a0
jmp 0xad0a
movq 0x38(%rsp), %rdi
movsd 0x28(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x87e0
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/complex.c
// Function: IsComplex
static int IsComplex(lua_State *L)
    {
    if(!testcomplex(L, 1, NULL))
        lua_pushboolean(L, 0);
    else
        lua_pushboolean(L, 1);
    return 1;
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c00
cmpl $0x0, %eax
jne 0xad79
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x8890
jmp 0xad87
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x8890
movl $0x1, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/complex.c
// Function: ComplexArray
static int ComplexArray(lua_State *L)
    {
    double x, y;
    int i, j, tbl;
    int n = luaL_len(L, 1);
    lua_newtable(L);
    tbl = lua_gettop(L);
    j = 0;
    for(i=0; i < n; )
        {
        lua_rawgeti(L, 1, ++i);
        x = luaL_optnumber(L, -1, 0);
        lua_rawgeti(L, 1, ++i);
        y = luaL_optnumber(L, -1, 0);
        lua_pop(L, 2);
        pushcomplex(L, x + I*y);
        lua_rawseti(L, tbl, ++j);
        }
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x8d40
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8320
movq 0x30(%rsp), %rdi
callq 0x8060
movl %eax, 0x14(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0xaec3
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movslq %eax, %rdx
movl $0x1, %esi
callq 0x83b0
movq 0x30(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
callq 0x8370
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movslq %eax, %rdx
movl $0x1, %esi
callq 0x83b0
movq 0x30(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
callq 0x8370
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x80c0
movq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm1
movsd 0x20(%rsp), %xmm3
xorps %xmm2, %xmm2
mulsd %xmm3, %xmm2
movsd 0x18241(%rip), %xmm0    # 0x230c0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm1
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x87e0
movq 0x30(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movslq %eax, %rdx
callq 0x8770
jmp 0xadd8
movl $0x1, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/datahandling.c
// Function: moonglmath_sizeoftype
size_t sizeoftype(int type)
    {
    switch(type)
        {
        case MOONGLMATH_TYPE_CHAR:   return sizeof(int8_t);
        case MOONGLMATH_TYPE_UCHAR:  return sizeof(uint8_t);
        case MOONGLMATH_TYPE_SHORT:  return sizeof(int16_t);
        case MOONGLMATH_TYPE_USHORT: return sizeof(uint16_t);
        case MOONGLMATH_TYPE_INT:    return sizeof(int32_t);
        case MOONGLMATH_TYPE_UINT:   return sizeof(uint32_t);
        case MOONGLMATH_TYPE_LONG:   return sizeof(int64_t);
        case MOONGLMATH_TYPE_ULONG: return sizeof(uint64_t);
        case MOONGLMATH_TYPE_FLOAT:  return sizeof(float);
        case MOONGLMATH_TYPE_DOUBLE: return sizeof(double);
        default:
            return 0;
        }
    return 0;
    }

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0x9, %eax
ja 0xaf6d
movq -0x18(%rsp), %rax
leaq 0x182ca(%rip), %rcx     # 0x231c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x1, -0x8(%rsp)
jmp 0xaf76
movq $0x1, -0x8(%rsp)
jmp 0xaf76
movq $0x2, -0x8(%rsp)
jmp 0xaf76
movq $0x2, -0x8(%rsp)
jmp 0xaf76
movq $0x4, -0x8(%rsp)
jmp 0xaf76
movq $0x4, -0x8(%rsp)
jmp 0xaf76
movq $0x8, -0x8(%rsp)
jmp 0xaf76
movq $0x8, -0x8(%rsp)
jmp 0xaf76
movq $0x4, -0x8(%rsp)
jmp 0xaf76
movq $0x8, -0x8(%rsp)
jmp 0xaf76
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/datahandling.c
// Function: moonglmath_toflattable
int toflattable(lua_State *L, int arg)
/* Creates a flat table with all the arguments starting from arg, and leaves 
 * it on top of the stack.
 */
    {
    int table_index, last_arg, i, n;
    if(lua_type(L, arg) == LUA_TTABLE)
        {
        lua_newtable(L);
        n = Flatten1_(L, lua_gettop(L), 0, arg);
        }
    else
        {
        /* create a table with all the arguments, and flatten it */
        last_arg = lua_gettop(L);
        lua_newtable(L);
        table_index = lua_gettop(L);
        for(i=arg; i <= last_arg; i++)
            {
            lua_pushvalue(L, i);
            lua_rawseti(L, table_index, i-arg+1);
            }
        lua_newtable(L);
        n = Flatten1_(L, lua_gettop(L), 0, table_index);
        }
    return n;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x8d20
cmpl $0x5, %eax
jne 0xafdd
movq 0x30(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8320
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8060
movq 0x10(%rsp), %rdi
movl %eax, %esi
movl 0x2c(%rsp), %ecx
xorl %edx, %edx
callq 0xb0a0
movl %eax, 0x1c(%rsp)
jmp 0xb088
movq 0x30(%rsp), %rdi
callq 0x8060
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8320
movq 0x30(%rsp), %rdi
callq 0x8060
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x24(%rsp), %eax
jg 0xb050
movq 0x30(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x8650
movq 0x30(%rsp), %rdi
movl 0x28(%rsp), %esi
movl 0x20(%rsp), %eax
subl 0x2c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x8770
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xb00f
movq 0x30(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8320
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8060
movq 0x8(%rsp), %rdi
movl %eax, %esi
movl 0x28(%rsp), %ecx
xorl %edx, %edx
callq 0xb0a0
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/datahandling.c
// Function: Flatten1_
static int Flatten1_(lua_State *L, int table_index, int cur_index, int arg)
    {
    int len, i, top, m, n=0;

    if(lua_type(L, arg) != LUA_TTABLE)
        return luaL_error(L, "table expected");

    lua_len(L, arg);
    len = lua_tointeger(L, -1);
    lua_pop(L, 1);

    if(len==0) return n;

    for(i=1; i<=len; i++)
        {
        lua_geti(L, arg, i);
        top = lua_gettop(L);
        if(lua_type(L, top) == LUA_TTABLE)
            {
            m = Flatten1_(L, table_index, cur_index, top);
            n += m;
            cur_index += m;
            lua_remove(L, top);
            }
        else
            {
            n++;
            cur_index++;
            lua_rawseti(L, table_index, cur_index);
            }
        }
    return n;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x8d20
cmpl $0x5, %eax
je 0xb0ec
movq 0x28(%rsp), %rdi
leaq 0x18193(%rip), %rsi     # 0x2326f
movb $0x0, %al
callq 0x8b30
movl %eax, 0x34(%rsp)
jmp 0xb217
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x8850
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x8290
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
cmpl $0x0, 0x18(%rsp)
jne 0xb134
movl 0x8(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0xb217
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jg 0xb20f
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
movslq 0x14(%rsp), %rdx
callq 0x8e10
movq 0x28(%rsp), %rdi
callq 0x8060
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x8d20
cmpl $0x5, %eax
jne 0xb1d4
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x10(%rsp), %ecx
callq 0xb0a0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
addl 0x20(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x10(%rsp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x89d0
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
jmp 0xb1fd
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movslq 0x20(%rsp), %rdx
callq 0x8770
jmp 0xb1ff
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xb13c
movl 0x8(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/datahandling.c
// Function: moonglmath_checkdata
int checkdata(lua_State *L, int arg, int type, void *dst, size_t dstsize)
    {
    size_t n = toflattable(L, arg);
    int err = testdata(L, type, n, dst, dstsize);
    if(err)
        {
        lua_pop(L, 1); /* flat table */
        return luaL_argerror(L, arg, errstring(err));
        }
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x84c0
cltq
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl 0x30(%rsp), %esi
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x85f0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0xbf79
movq 0x38(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %edi
callq 0x8550
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x81b0
movl %eax, 0x44(%rsp)
jmp 0xbf81
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/datahandling.c
// Function: Flatten
static int Flatten(lua_State *L)
    {
    int n, i, table_index;
    n = toflattable(L, 1);
    table_index = lua_gettop(L);
    luaL_checkstack(L, n, "too many elements, cannot grow Lua stack");
    for(i = 0; i < n; i++)
        lua_rawgeti(L, table_index, i+1);
    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x84c0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8060
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
leaq 0x16908(%rip), %rdx     # 0x232a2
callq 0x88d0
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0xc9d6
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
movl 0x8(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x83b0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xc9a7
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/enums.c
// Function: moonglmath_open_enums
void moonglmath_open_enums(lua_State *L)
    {
    uint32_t domain;

    luaL_setfuncs(L, Functions, 0);

    /* Add all the code<->string mappings */
#define ADD(what, s) do { enums_new(L, domain, MOONGLMATH_##what, s); } while(0)
    domain = DOMAIN_ISROW; 
    ADD(COLUMN, "column");
    ADD(ROW, "row");

    domain = DOMAIN_TYPE; 
    ADD(TYPE_CHAR, "char");
    ADD(TYPE_UCHAR, "uchar");
    ADD(TYPE_SHORT, "short");
    ADD(TYPE_USHORT, "ushort");
    ADD(TYPE_INT, "int");
    ADD(TYPE_UINT, "uint");
    ADD(TYPE_LONG, "long");
    ADD(TYPE_ULONG, "ulong");
    ADD(TYPE_FLOAT, "float");
    ADD(TYPE_DOUBLE, "double");
#undef ADD
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x1bf8b(%rip), %rsi     # 0x29420
xorl %edx, %edx
callq 0x81a0
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
xorl %edx, %edx
leaq 0x15e30(%rip), %rcx     # 0x232e6
callq 0xd600
jmp 0xd4bd
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x1, %edx
leaq 0x15e47(%rip), %rcx     # 0x23319
callq 0xd600
movl $0x1, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x1, %edx
leaq 0x15dfa(%rip), %rcx     # 0x232ee
callq 0xd600
jmp 0xd4fb
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x2, %edx
leaq 0x15ddd(%rip), %rcx     # 0x232ed
callq 0xd600
jmp 0xd517
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x3, %edx
leaq 0x15dc8(%rip), %rcx     # 0x232f4
callq 0xd600
jmp 0xd533
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x4, %edx
leaq 0x15dab(%rip), %rcx     # 0x232f3
callq 0xd600
jmp 0xd54f
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x5, %edx
leaq 0x15d97(%rip), %rcx     # 0x232fb
callq 0xd600
jmp 0xd56b
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x6, %edx
leaq 0x15d7a(%rip), %rcx     # 0x232fa
callq 0xd600
jmp 0xd587
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x7, %edx
leaq 0x15d64(%rip), %rcx     # 0x23300
callq 0xd600
jmp 0xd5a3
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x8, %edx
leaq 0x15d47(%rip), %rcx     # 0x232ff
callq 0xd600
jmp 0xd5bf
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x9, %edx
leaq 0x15d31(%rip), %rcx     # 0x23305
callq 0xd600
jmp 0xd5db
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0xa, %edx
leaq 0x15d1b(%rip), %rcx     # 0x2330b
callq 0xd600
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/enums.c
// Function: Enum
static int Enum(lua_State *L)
/* { strings } = glmath.enum('type') lists all the values for a given enum type */
    { 
    const char *s = luaL_checkstring(L, 1); 
#define CASE(xxx) if(strcmp(s, ""#xxx) == 0) return values##xxx(L)
    CASE(isrow);
    CASE(type);
#undef CASE
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8600
movq %rax, (%rsp)
movq (%rsp), %rdi
leaq 0x1428c(%rip), %rsi     # 0x23317
callq 0x8700
cmpl $0x0, %eax
jne 0xf0a7
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x8590
movl %eax, 0x14(%rsp)
jmp 0xf0d9
movq (%rsp), %rdi
leaq 0x1490c(%rip), %rsi     # 0x239be
callq 0x8700
cmpl $0x0, %eax
jne 0xf0d1
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x8590
movl %eax, 0x14(%rsp)
jmp 0xf0d9
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/funcs.c
// Function: Inv
static int Inv(lua_State *L)
    {
    if(ismat(L,1)) return mat_Inv(L);
    if(isquat(L,1)) return quat_Inv(L);
    if(iscomplex(L,1)) return complex_Inv(L);
    return badarg(L, 1);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x134cb(%rip), %rdx     # 0x23355
callq 0x8180
cmpl $0x0, %eax
je 0xfea4
movq 0x8(%rsp), %rdi
callq 0x8aa0
movl %eax, 0x14(%rsp)
jmp 0xff14
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x134c5(%rip), %rdx     # 0x2337a
callq 0x8180
cmpl $0x0, %eax
je 0xfecf
movq 0x8(%rsp), %rdi
callq 0x84b0
movl %eax, 0x14(%rsp)
jmp 0xff14
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x131e8(%rip), %rdx     # 0x230c8
callq 0x8180
cmpl $0x0, %eax
je 0xfefa
movq 0x8(%rsp), %rdi
callq 0x8820
movl %eax, 0x14(%rsp)
jmp 0xff14
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x13459(%rip), %rdx     # 0x23364
callq 0x81b0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/funcs.c
// Function: Norm
static int Norm(lua_State *L)
    {
    if(isvec(L,1)) return vec_Norm(L);
    if(isquat(L,1)) return quat_Norm(L);
    if(iscomplex(L,1)) return complex_Norm(L);
    return badarg(L, 1);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x13450(%rip), %rdx     # 0x2338a
callq 0x8180
cmpl $0x0, %eax
je 0xff54
movq 0x8(%rsp), %rdi
callq 0x8330
movl %eax, 0x14(%rsp)
jmp 0xffc4
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x13415(%rip), %rdx     # 0x2337a
callq 0x8180
cmpl $0x0, %eax
je 0xff7f
movq 0x8(%rsp), %rdi
callq 0x8e40
movl %eax, 0x14(%rsp)
jmp 0xffc4
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x13138(%rip), %rdx     # 0x230c8
callq 0x8180
cmpl $0x0, %eax
je 0xffaa
movq 0x8(%rsp), %rdi
callq 0x8d90
movl %eax, 0x14(%rsp)
jmp 0xffc4
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x133a9(%rip), %rdx     # 0x23364
callq 0x81b0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/funcs.c
// Function: Norm2
static int Norm2(lua_State *L)
    {
    if(isvec(L,1)) return vec_Norm2(L);
    if(isquat(L,1)) return quat_Norm2(L);
    if(iscomplex(L,1)) return complex_Norm2(L);
    return badarg(L, 1);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x133a0(%rip), %rdx     # 0x2338a
callq 0x8180
cmpl $0x0, %eax
je 0x10004
movq 0x8(%rsp), %rdi
callq 0x8c50
movl %eax, 0x14(%rsp)
jmp 0x10074
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x13365(%rip), %rdx     # 0x2337a
callq 0x8180
cmpl $0x0, %eax
je 0x1002f
movq 0x8(%rsp), %rdi
callq 0x8710
movl %eax, 0x14(%rsp)
jmp 0x10074
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x13088(%rip), %rdx     # 0x230c8
callq 0x8180
cmpl $0x0, %eax
je 0x1005a
movq 0x8(%rsp), %rdi
callq 0x8280
movl %eax, 0x14(%rsp)
jmp 0x10074
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x132f9(%rip), %rdx     # 0x23364
callq 0x81b0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/funcs.c
// Function: Normalize
static int Normalize(lua_State *L)
    {
    if(isvec(L,1)) return vec_Normalize(L);
    if(isquat(L,1)) return quat_Normalize(L);
    if(iscomplex(L,1)) return complex_Normalize(L);
    return badarg(L, 1);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x131d0(%rip), %rdx     # 0x2338a
callq 0x8180
cmpl $0x0, %eax
je 0x101d4
movq 0x8(%rsp), %rdi
callq 0x8ea0
movl %eax, 0x14(%rsp)
jmp 0x10244
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x13195(%rip), %rdx     # 0x2337a
callq 0x8180
cmpl $0x0, %eax
je 0x101ff
movq 0x8(%rsp), %rdi
callq 0x8cb0
movl %eax, 0x14(%rsp)
jmp 0x10244
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12eb8(%rip), %rdx     # 0x230c8
callq 0x8180
cmpl $0x0, %eax
je 0x1022a
movq 0x8(%rsp), %rdi
callq 0x8210
movl %eax, 0x14(%rsp)
jmp 0x10244
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x13129(%rip), %rdx     # 0x23364
callq 0x81b0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/funcs.c
// Function: Clamp
static int Clamp(lua_State *L)
    {
    if(lua_isnumber(L,1)) return num_Clamp(L);
    if(isvec(L,1)) return vec_Clamp(L);
    if(ismat(L,1)) return mat_Clamp(L);
    return badarg(L, 1);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x1042d
movq 0x8(%rsp), %rdi
callq 0x8b40
movl %eax, 0x14(%rsp)
jmp 0x1049d
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12f4c(%rip), %rdx     # 0x2338a
callq 0x8180
cmpl $0x0, %eax
je 0x10458
movq 0x8(%rsp), %rdi
callq 0x8b80
movl %eax, 0x14(%rsp)
jmp 0x1049d
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12eec(%rip), %rdx     # 0x23355
callq 0x8180
cmpl $0x0, %eax
je 0x10483
movq 0x8(%rsp), %rdi
callq 0x8bc0
movl %eax, 0x14(%rsp)
jmp 0x1049d
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12ed0(%rip), %rdx     # 0x23364
callq 0x81b0
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]moonglmath/src/funcs.c
// Function: Mix
static int Mix(lua_State *L)
    {
    if(lua_isnumber(L,1)) return num_Mix(L);
    if(isvec(L,1)) return vec_Mix(L);
    if(ismat(L,1)) return mat_Mix(L);
    if(isquat(L,1)) return quat_Mix(L);
    return badarg(L, 1);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x104e0
movq 0x8(%rsp), %rdi
callq 0x8110
movl %eax, 0x14(%rsp)
jmp 0x1057b
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12e99(%rip), %rdx     # 0x2338a
callq 0x8180
cmpl $0x0, %eax
je 0x1050b
movq 0x8(%rsp), %rdi
callq 0x8990
movl %eax, 0x14(%rsp)
jmp 0x1057b
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12e39(%rip), %rdx     # 0x23355
callq 0x8180
cmpl $0x0, %eax
je 0x10536
movq 0x8(%rsp), %rdi
callq 0x8100
movl %eax, 0x14(%rsp)
jmp 0x1057b
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12e33(%rip), %rdx     # 0x2337a
callq 0x8180
cmpl $0x0, %eax
je 0x10561
movq 0x8(%rsp), %rdi
callq 0x80b0
movl %eax, 0x14(%rsp)
jmp 0x1057b
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12df2(%rip), %rdx     # 0x23364
callq 0x81b0
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]moonglmath/src/funcs.c
// Function: Step
static int Step(lua_State *L)
    {
    if(lua_isnumber(L,1)) return num_Step(L);
    if(isvec(L,1)) return vec_Step(L);
    if(ismat(L,1)) return mat_Step(L);
    return badarg(L, 1);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x1061d
movq 0x8(%rsp), %rdi
callq 0x8a50
movl %eax, 0x14(%rsp)
jmp 0x1068d
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12d5c(%rip), %rdx     # 0x2338a
callq 0x8180
cmpl $0x0, %eax
je 0x10648
movq 0x8(%rsp), %rdi
callq 0x83d0
movl %eax, 0x14(%rsp)
jmp 0x1068d
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12cfc(%rip), %rdx     # 0x23355
callq 0x8180
cmpl $0x0, %eax
je 0x10673
movq 0x8(%rsp), %rdi
callq 0x8e60
movl %eax, 0x14(%rsp)
jmp 0x1068d
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12ce0(%rip), %rdx     # 0x23364
callq 0x81b0
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]moonglmath/src/funcs.c
// Function: Smoothstep
static int Smoothstep(lua_State *L)
    {
    if(lua_isnumber(L,1)) return num_Smoothstep(L);
    if(isvec(L,1)) return vec_Smoothstep(L);
    if(ismat(L,1)) return mat_Smoothstep(L);
    return badarg(L, 1);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x106cd
movq 0x8(%rsp), %rdi
callq 0x8520
movl %eax, 0x14(%rsp)
jmp 0x1073d
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12cac(%rip), %rdx     # 0x2338a
callq 0x8180
cmpl $0x0, %eax
je 0x106f8
movq 0x8(%rsp), %rdi
callq 0x8a70
movl %eax, 0x14(%rsp)
jmp 0x1073d
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12c4c(%rip), %rdx     # 0x23355
callq 0x8180
cmpl $0x0, %eax
je 0x10723
movq 0x8(%rsp), %rdi
callq 0x88b0
movl %eax, 0x14(%rsp)
jmp 0x1073d
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12c30(%rip), %rdx     # 0x23364
callq 0x81b0
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]moonglmath/src/funcs.c
// Function: Fade
static int Fade(lua_State *L)
    {
    if(lua_isnumber(L,1)) return num_Fade(L);
    if(isvec(L,1)) return vec_Fade(L);
    if(ismat(L,1)) return mat_Fade(L);
    return badarg(L, 1);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x1077d
movq 0x8(%rsp), %rdi
callq 0x8e50
movl %eax, 0x14(%rsp)
jmp 0x107ed
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12bfc(%rip), %rdx     # 0x2338a
callq 0x8180
cmpl $0x0, %eax
je 0x107a8
movq 0x8(%rsp), %rdi
callq 0x8910
movl %eax, 0x14(%rsp)
jmp 0x107ed
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12b9c(%rip), %rdx     # 0x23355
callq 0x8180
cmpl $0x0, %eax
je 0x107d3
movq 0x8(%rsp), %rdi
callq 0x8390
movl %eax, 0x14(%rsp)
jmp 0x107ed
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x12b80(%rip), %rdx     # 0x23364
callq 0x81b0
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]moonglmath/src/hostmem.c
// Function: Write
static int Write(lua_State *L)
    {
    int t = lua_type(L, 3);
    if(t == LUA_TSTRING) return WritePack(L);
    if(t == LUA_TNIL) return WriteData(L);
    return luaL_argerror(L, 3, errstring(ERR_TYPE));    
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x8d20
movl %eax, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jne 0x10963
movq 0x18(%rsp), %rdi
callq 0x10f20
movl %eax, 0x24(%rsp)
jmp 0x109a4
cmpl $0x0, 0x14(%rsp)
jne 0x1097a
movq 0x18(%rsp), %rdi
callq 0x11000
movl %eax, 0x24(%rsp)
jmp 0x109a4
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x8550
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x81b0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/hostmem.c
// Function: Copy
static int Copy(lua_State *L)
    {
    int t = lua_type(L, 4);
    if(t == LUA_TLIGHTUSERDATA) return CopyPtr(L);
    if(t == LUA_TUSERDATA) return CopyHostmem(L);
    return luaL_argerror(L, 4, errstring(ERR_TYPE));    
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x4, %esi
callq 0x8d20
movl %eax, 0x14(%rsp)
cmpl $0x2, 0x14(%rsp)
jne 0x109e3
movq 0x18(%rsp), %rdi
callq 0x110f0
movl %eax, 0x24(%rsp)
jmp 0x10a24
cmpl $0x7, 0x14(%rsp)
jne 0x109fa
movq 0x18(%rsp), %rdi
callq 0x111f0
movl %eax, 0x24(%rsp)
jmp 0x10a24
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x8550
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x4, %esi
callq 0x81b0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)