// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/scripting.c
// Function: luaRedisGenericCommand
int luaRedisGenericCommand(lua_State *lua, int raise_error) {
    int j, argc = lua_gettop(lua);
    struct redisCommand *cmd;
    client *c = server.lua_client;
    sds reply;

    /* Cached across calls. */
    static robj **argv = NULL;
    static int argv_size = 0;
    static robj *cached_objects[LUA_CMD_OBJCACHE_SIZE];
    static size_t cached_objects_len[LUA_CMD_OBJCACHE_SIZE];
    static int inuse = 0;   /* Recursive calls detection. */

    /* By using Lua debug hooks it is possible to trigger a recursive call
     * to luaRedisGenericCommand(), which normally should never happen.
     * To make this function reentrant is futile and makes it slower, but
     * we should at least detect such a misuse, and abort. */
    if (inuse) {
        char *recursion_warning =
            "luaRedisGenericCommand() recursive call detected. "
            "Are you doing funny stuff with Lua debug hooks?";
        serverLog(LL_WARNING,"%s",recursion_warning);
        luaPushError(lua,recursion_warning);
        return 1;
    }
    inuse++;

    /* Require at least one argument */
    if (argc == 0) {
        luaPushError(lua,
            "Please specify at least one argument for redis.call()");
        inuse--;
        return raise_error ? luaRaiseError(lua) : 1;
    }

    /* Build the arguments vector */
    if (argv_size < argc) {
        argv = zrealloc(argv,sizeof(robj*)*argc);
        argv_size = argc;
    }

    for (j = 0; j < argc; j++) {
        char *obj_s;
        size_t obj_len;
        char dbuf[64];

        if (lua_type(lua,j+1) == LUA_TNUMBER) {
            /* We can't use lua_tolstring() for number -> string conversion
             * since Lua uses a format specifier that loses precision. */
            lua_Number num = lua_tonumber(lua,j+1);

            obj_len = snprintf(dbuf,sizeof(dbuf),"%.17g",(double)num);
            obj_s = dbuf;
        } else {
            obj_s = (char*)lua_tolstring(lua,j+1,&obj_len);
            if (obj_s == NULL) break; /* Not a string. */
        }

        /* Try to use a cached object. */
        if (j < LUA_CMD_OBJCACHE_SIZE && cached_objects[j] &&
            cached_objects_len[j] >= obj_len)
        {
            sds s = cached_objects[j]->ptr;
            argv[j] = cached_objects[j];
            cached_objects[j] = NULL;
            memcpy(s,obj_s,obj_len+1);
            sdssetlen(s, obj_len);
        } else {
            argv[j] = createStringObject(obj_s, obj_len);
        }
    }

    /* Check if one of the arguments passed by the Lua script
     * is not a string or an integer (lua_isstring() return true for
     * integers as well). */
    if (j != argc) {
        j--;
        while (j >= 0) {
            decrRefCount(argv[j]);
            j--;
        }
        luaPushError(lua,
            "Lua redis() command arguments must be strings or integers");
        inuse--;
        return raise_error ? luaRaiseError(lua) : 1;
    }

    /* Setup our fake client for command execution */
    c->argv = argv;
    c->argc = argc;

    /* Log the command if debugging is active. */
    if (ldb.active && ldb.step) {
        sds cmdlog = sdsnew("<redis>");
        for (j = 0; j < c->argc; j++) {
            if (j == 10) {
                cmdlog = sdscatprintf(cmdlog," ... (%d more)",
                    c->argc-j-1);
                break;
            } else {
                cmdlog = sdscatlen(cmdlog," ",1);
                cmdlog = sdscatsds(cmdlog,c->argv[j]->ptr);
            }
        }
        ldbLog(cmdlog);
    }

    /* Command lookup */
    cmd = lookupCommand(argv[0]->ptr);
    if (!cmd || ((cmd->arity > 0 && cmd->arity != argc) ||
                   (argc < -cmd->arity)))
    {
        if (cmd)
            luaPushError(lua,
                "Wrong number of args calling Redis command From Lua script");
        else
            luaPushError(lua,"Unknown Redis command called from Lua script");
        goto cleanup;
    }
    c->cmd = c->lastcmd = cmd;

    /* There are commands that are not allowed inside scripts. */
    if (cmd->flags & CMD_NOSCRIPT) {
        luaPushError(lua, "This Redis command is not allowed from scripts");
        goto cleanup;
    }

    /* Write commands are forbidden against read-only slaves, or if a
     * command marked as non-deterministic was already called in the context
     * of this script. */
    if (cmd->flags & CMD_WRITE) {
        if (server.lua_random_dirty && !server.lua_replicate_commands) {
            luaPushError(lua,
                "Write commands not allowed after non deterministic commands. Call redis.replicate_commands() at the start of your script in order to switch to single commands replication mode.");
            goto cleanup;
        } else if (server.masterhost && server.repl_slave_ro &&
                   !server.loading &&
                   !(server.lua_caller->flags & CLIENT_MASTER))
        {
            luaPushError(lua, shared.roslaveerr->ptr);
            goto cleanup;
        } else if (server.stop_writes_on_bgsave_err &&
                   server.saveparamslen > 0 &&
                   server.lastbgsave_status == C_ERR)
        {
            luaPushError(lua, shared.bgsaveerr->ptr);
            goto cleanup;
        }
    }

    /* If we reached the memory limit configured via maxmemory, commands that
     * could enlarge the memory usage are not allowed, but only if this is the
     * first write in the context of this script, otherwise we can't stop
     * in the middle. */
    if (server.maxmemory && server.lua_write_dirty == 0 &&
        (cmd->flags & CMD_DENYOOM))
    {
        if (freeMemoryIfNeeded() == C_ERR) {
            luaPushError(lua, shared.oomerr->ptr);
            goto cleanup;
        }
    }

    if (cmd->flags & CMD_RANDOM) server.lua_random_dirty = 1;
    if (cmd->flags & CMD_WRITE) server.lua_write_dirty = 1;

    /* If this is a Redis Cluster node, we need to make sure Lua is not
     * trying to access non-local keys, with the exception of commands
     * received from our master or when loading the AOF back in memory. */
    if (server.cluster_enabled && !server.loading &&
        !(server.lua_caller->flags & CLIENT_MASTER))
    {
        /* Duplicate relevant flags in the lua client. */
        c->flags &= ~(CLIENT_READONLY|CLIENT_ASKING);
        c->flags |= server.lua_caller->flags & (CLIENT_READONLY|CLIENT_ASKING);
        if (getNodeByQuery(c,c->cmd,c->argv,c->argc,NULL,NULL) !=
                           server.cluster->myself)
        {
            luaPushError(lua,
                "Lua script attempted to access a non local key in a "
                "cluster node");
            goto cleanup;
        }
    }

    /* If we are using single commands replication, we need to wrap what
     * we propagate into a MULTI/EXEC block, so that it will be atomic like
     * a Lua script in the context of AOF and slaves. */
    if (server.lua_replicate_commands &&
        !server.lua_multi_emitted &&
        server.lua_write_dirty &&
        server.lua_repl != PROPAGATE_NONE)
    {
        execCommandPropagateMulti(server.lua_caller);
        server.lua_multi_emitted = 1;
    }

    /* Run the command */
    int call_flags = CMD_CALL_SLOWLOG | CMD_CALL_STATS;
    if (server.lua_replicate_commands) {
        /* Set flags according to redis.set_repl() settings. */
        if (server.lua_repl & PROPAGATE_AOF)
            call_flags |= CMD_CALL_PROPAGATE_AOF;
        if (server.lua_repl & PROPAGATE_REPL)
            call_flags |= CMD_CALL_PROPAGATE_REPL;
    }
    call(c,call_flags);

    /* Convert the result of the Redis command into a suitable Lua type.
     * The first thing we need is to create a single string from the client
     * output buffers. */
    if (listLength(c->reply) == 0 && c->bufpos < PROTO_REPLY_CHUNK_BYTES) {
        /* This is a fast path for the common case of a reply inside the
         * client static buffer. Don't create an SDS string but just use
         * the client buffer directly. */
        c->buf[c->bufpos] = '\0';
        reply = c->buf;
        c->bufpos = 0;
    } else {
        reply = sdsnewlen(c->buf,c->bufpos);
        c->bufpos = 0;
        while(listLength(c->reply)) {
            robj *o = listNodeValue(listFirst(c->reply));

            reply = sdscatlen(reply,o->ptr,sdslen(o->ptr));
            listDelNode(c->reply,listFirst(c->reply));
        }
    }
    if (raise_error && reply[0] != '-') raise_error = 0;
    redisProtocolToLuaType(lua,reply);

    /* If the debugger is active, log the reply from Redis. */
    if (ldb.active && ldb.step)
        ldbLogRedisReply(reply);

    /* Sort the output array if needed, assuming it is a non-null multi bulk
     * reply as expected. */
    if ((cmd->flags & CMD_SORT_FOR_SCRIPT) &&
        (server.lua_replicate_commands == 0) &&
        (reply[0] == '*' && reply[1] != '-')) {
            luaSortArray(lua);
    }
    if (reply != c->buf) sdsfree(reply);
    c->reply_bytes = 0;

cleanup:
    /* Clean up. Command code may have changed argv/argc so we use the
     * argv/argc of the client instead of the local variables. */
    for (j = 0; j < c->argc; j++) {
        robj *o = c->argv[j];

        /* Try to cache the object in the cached_objects array.
         * The object must be small, SDS-encoded, and with refcount = 1
         * (we must be the only owner) for us to cache it. */
        if (j < LUA_CMD_OBJCACHE_SIZE &&
            o->refcount == 1 &&
            (o->encoding == OBJ_ENCODING_RAW ||
             o->encoding == OBJ_ENCODING_EMBSTR) &&
            sdslen(o->ptr) <= LUA_CMD_OBJCACHE_MAX_LEN)
        {
            sds s = o->ptr;
            if (cached_objects[j]) decrRefCount(cached_objects[j]);
            cached_objects[j] = o;
            cached_objects_len[j] = sdsalloc(s);
        } else {
            decrRefCount(o);
        }
    }

    if (c->argv != argv) {
        zfree(c->argv);
        argv = NULL;
        argv_size = 0;
    }

    if (raise_error) {
        /* If we are here we should have an error in the stack, in the
         * form of a table with an "err" field. Extract the string to
         * return the plain error. */
        inuse--;
        return luaRaiseError(lua);
    }
    inuse--;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
movq %rdi, %rbp
callq 0x7846b
cmpl $0x0, 0xaba65(%rip)     # 0x10e5d0
je 0x62ba5
leaq 0x5aa52(%rip), %rsi     # 0xbd5c6
leaq 0x57c33(%rip), %r14     # 0xba7ae
pushq $0x3
popq %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2b699
movq %rbp, %rdi
movq %r14, %rsi
callq 0x6270d
pushq $0x1
popq %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
leaq 0x96cf9(%rip), %rax     # 0xf98a8
movq 0x9d0(%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x1, 0xaba0b(%rip)     # 0x10e5d0
testl %r15d, %r15d
je 0x62d27
movl %ebx, (%rsp)
cmpl %r15d, 0xab7f0(%rip)    # 0x10e3c8
jge 0x62bfb
movq 0xab7df(%rip), %rdi     # 0x10e3c0
movl %r15d, %esi
shlq $0x3, %rsi
callq 0x32863
movq %rax, 0xab7cc(%rip)     # 0x10e3c0
movl %r15d, 0xab7cd(%rip)    # 0x10e3c8
xorl %r13d, %r13d
testl %r15d, %r15d
movl $0x0, %r14d
movl %r15d, 0x4(%rsp)
cmovgl %r15d, %r14d
leaq 0xab7b9(%rip), %r15     # 0x10e3d0
leaq 0xab8b2(%rip), %rax     # 0x10e4d0
movq %rax, 0x18(%rsp)
xorl %r12d, %r12d
movq %rbp, 0x20(%rsp)
cmpq %r12, %r14
je 0x62d5d
leaq 0x1(%r12), %rbx
movq %rbp, %rdi
movl %ebx, %esi
callq 0x786b8
movq %rbp, %rdi
movl %ebx, %esi
cmpl $0x3, %eax
jne 0x62c93
callq 0x7885f
movq %r13, 0x28(%rsp)
movq %r14, %r13
movq %r15, %r14
movq %rbp, %r15
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
pushq $0x40
popq %rsi
leaq 0x4ece1(%rip), %rdx     # 0xb1953
movb $0x1, %al
callq 0x26120
cltq
movq %rax, 0x8(%rsp)
movq %rbp, %rax
movq %r15, %rbp
movq %r14, %r15
movq %r13, %r14
movq 0x28(%rsp), %r13
jmp 0x62ca6
leaq 0x8(%rsp), %rdx
callq 0x788e1
testq %rax, %rax
je 0x62d5a
cmpq $0x20, %r12
jae 0x62d00
movq (%r13,%r15), %rcx
movq 0x8(%rsp), %rdx
testq %rcx, %rcx
je 0x62d05
leaq 0xab80e(%rip), %rsi     # 0x10e4d0
cmpq %rdx, (%r13,%rsi)
jb 0x62d05
movq 0x8(%rcx), %rbp
movq 0xab6ec(%rip), %rsi     # 0x10e3c0
movq %rcx, (%rsi,%r12,8)
andq $0x0, (%r13,%r15)
incq %rdx
movq %rbp, %rdi
movq %rax, %rsi
callq 0x26c50
movq 0x8(%rsp), %rsi
movq %rbp, %rdi
movq 0x20(%rsp), %rbp
callq 0x63338
jmp 0x62d1b
movq 0x8(%rsp), %rdx
movq %rax, %rdi
movq %rdx, %rsi
callq 0x39e29
movq 0xab6a9(%rip), %rcx     # 0x10e3c0
movq %rax, (%rcx,%r12,8)
addq $0x8, %r13
movq %rbx, %r12
jmp 0x62c2b
leaq 0x57ae2(%rip), %rsi     # 0xba810
movq %rbp, %rdi
callq 0x6270d
decl 0xab894(%rip)           # 0x10e5d0
testl %ebx, %ebx
je 0x62b93
movq %rbp, %rdi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x627f7
movl %r12d, %r14d
movl 0x4(%rsp), %ecx
cmpl %ecx, %r14d
movq 0x10(%rsp), %rbx
jne 0x62df5
movq 0xab64a(%rip), %rax     # 0x10e3c0
movq %rax, 0x40(%rbx)
movl %ecx, 0x38(%rbx)
cmpl $0x0, 0xab4e0(%rip)     # 0x10e264
je 0x62e65
cmpl $0x0, 0xab5fb(%rip)     # 0x10e38c
je 0x62e65
movq %r15, %r13
leaq 0x57adf(%rip), %rdi     # 0xba880
callq 0x3115a
movq %rbx, %r14
xorl %ebx, %ebx
leaq 0x5329f(%rip), %r15     # 0xb6051
pushq $0x1
popq %r12
movslq 0x38(%r14), %rdx
cmpq %rdx, %rbx
jge 0x62e4e
cmpq $0xa, %rbx
je 0x62e3a
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x31758
movq 0x10(%rsp), %r14
movq 0x40(%r14), %rcx
movq (%rcx,%rbx,8), %rcx
movq 0x8(%rcx), %rsi
movq %rax, %rdi
callq 0x317de
incq %rbx
jmp 0x62db6
movl %r14d, %ebx
movl (%rsp), %r14d
testq %rbx, %rbx
jle 0x62e17
movq 0xab5b8(%rip), %rax     # 0x10e3c0
movq -0x8(%rax,%rbx,8), %rdi
decq %rbx
callq 0x3a265
jmp 0x62dfc
leaq 0x57a28(%rip), %rsi     # 0xba846
movq %rbp, %rdi
callq 0x6270d
decl 0xab7a4(%rip)           # 0x10e5d0
testl %r14d, %r14d
jne 0x6332b
jmp 0x62b93
addl $-0xb, %edx
leaq 0x57a44(%rip), %rsi     # 0xba888
movq %rax, %rdi
xorl %eax, %eax
callq 0x31a38
movq %rax, %rdi
callq 0x627e8
movq 0xab563(%rip), %rax     # 0x10e3c0
movq 0x10(%rsp), %rbx
movq %r13, %r15
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2e0f6
testq %rax, %rax
je 0x62ea5
movq %rax, %r12
movl 0x10(%rax), %eax
testl %eax, %eax
setg %cl
movl 0x4(%rsp), %esi
cmpl %esi, %eax
setne %dl
andb %cl, %dl
negl %eax
cmpl %eax, %esi
setl %al
orb %dl, %al
cmpb $0x1, %al
jne 0x62eb1
leaq 0x579f7(%rip), %rsi     # 0xba897
jmp 0x63231
leaq 0x57a26(%rip), %rsi     # 0xba8d2
jmp 0x63231
movq %r12, 0x50(%rbx)
movq %r12, 0x48(%rbx)
movl 0x20(%r12), %eax
testb $0x40, %al
jne 0x62fb9
testb $0x1, %al
jne 0x62fc5
testb $0x4, %al
je 0x62eff
leaq 0x969cf(%rip), %rcx     # 0xf98a8
cmpq $0x0, 0x908(%rcx)
je 0x62eff
cmpl $0x0, 0x9f8(%rcx)
jne 0x62eff
callq 0x2ea13
cmpl $-0x1, %eax
je 0x6321f
movl 0x20(%r12), %eax
testb %al, %al
jns 0x62f14
leaq 0x9699e(%rip), %rcx     # 0xf98a8
movl $0x1, 0x9fc(%rcx)
testb $0x1, %al
movl (%rsp), %r14d
je 0x62f2d
leaq 0x96985(%rip), %rax     # 0xf98a8
movl $0x1, 0x9f8(%rax)
leaq 0x96974(%rip), %r13     # 0xf98a8
cmpl $0x0, 0x99c(%r13)
je 0x62ff2
cmpl $0x0, 0x31c(%r13)
jne 0x62ff2
movq 0x9d8(%r13), %rax
testb $0x2, 0x98(%rax)
jne 0x62ff2
movl $0xfffdfdff, %ecx       # imm = 0xFFFDFDFF
andl 0x98(%rbx), %ecx
movl %ecx, 0x98(%rbx)
movl $0x20200, %edx          # imm = 0x20200
andl 0x98(%rax), %edx
orl %ecx, %edx
movl %edx, 0x98(%rbx)
movq 0x48(%rbx), %rsi
movq 0x40(%rbx), %rdx
movl 0x38(%rbx), %ecx
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x619bf
movq 0x9b0(%r13), %rcx
cmpq (%rcx), %rax
je 0x62ff2
leaq 0x57a2b(%rip), %rsi     # 0xba9df
jmp 0x63231
leaq 0x5793f(%rip), %rsi     # 0xba8ff
jmp 0x63231
leaq 0x968dc(%rip), %rdx     # 0xf98a8
cmpl $0x0, 0x9fc(%rdx)
je 0x630a0
cmpl $0x0, 0xa00(%rdx)
jne 0x630a0
leaq 0x57941(%rip), %rsi     # 0xba92e
jmp 0x63231
movl 0xa00(%r13), %eax
testl %eax, %eax
je 0x63039
cmpl $0x0, 0xa04(%r13)
jne 0x63039
cmpl $0x0, 0x9f8(%r13)
je 0x63039
cmpl $0x0, 0xa08(%r13)
je 0x63039
movq 0x9d8(%r13), %rdi
callq 0x57027
movl $0x1, 0xa04(%r13)
movl 0xa00(%r13), %eax
testl %eax, %eax
pushq $0x3
popq %rsi
je 0x63058
movl 0xa08(%r13), %eax
movl %eax, %ecx
andl $0x1, %ecx
shll $0x2, %eax
andl $0x8, %eax
leal (%rax,%rcx,4), %esi
addl $0x3, %esi
movq %rbx, %rdi
callq 0x2e246
movq 0x68(%rbx), %rax
cmpq $0x0, 0x28(%rax)
sete %al
movl 0x1c0(%rbx), %ecx
movslq %ecx, %rsi
cmpl $0x4000, %esi           # imm = 0x4000
setl %cl
andb %al, %cl
leaq 0x1c4(%rbx), %r15
cmpb $0x1, %cl
jne 0x630ef
movb $0x0, 0x1c4(%rbx,%rsi)
andl $0x0, 0x1c0(%rbx)
jmp 0x6314b
cmpq $0x0, 0x828(%rdx)
je 0x6315c
cmpl $0x0, 0x884(%rdx)
je 0x6315c
cmpl $0x0, 0x31c(%rdx)
jne 0x6315c
movq 0x9d8(%rdx), %rcx
testb $0x2, 0x98(%rcx)
jne 0x6315c
leaq 0x9722d(%rip), %rax     # 0xfa310
movq 0xc0(%rax), %rax
jmp 0x6322d
movq %rbx, %r13
movq %rbp, %rbx
movq %r15, %rdi
callq 0x31018
movq %rax, %r15
andl $0x0, 0x1c0(%r13)
movq 0x68(%r13), %rax
cmpq $0x0, 0x28(%rax)
je 0x63145
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rbp
movq %rbp, %rdi
callq 0x63370
movq %r15, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x31758
movq %rax, %r15
movq 0x68(%r13), %rdi
movq (%rdi), %rsi
callq 0x26fa8
jmp 0x63108
movq %rbx, %rbp
movq %r13, %rbx
testl %r14d, %r14d
je 0x631a4
xorl %eax, %eax
cmpb $0x2d, (%r15)
cmovnel %eax, %r14d
jmp 0x631a7
cmpl $0x0, 0x784(%rdx)
je 0x62ece
leaq 0x96738(%rip), %rcx     # 0xf98a8
cmpl $0x0, 0x740(%rcx)
jle 0x62ece
leaq 0x96724(%rip), %rcx     # 0xf98a8
cmpl $-0x1, 0x780(%rcx)
jne 0x62ece
leaq 0x97178(%rip), %rax     # 0xfa310
movq 0xb0(%rax), %rax
jmp 0x6322d
xorl %r14d, %r14d
movq %rbp, %rdi
movq %r15, %rsi
callq 0x62475
cmpl $0x0, 0xab0ab(%rip)     # 0x10e264
je 0x631cc
cmpl $0x0, 0xab1ca(%rip)     # 0x10e38c
je 0x631cc
movq %r15, %rdi
callq 0x633a8
testb $0x1, 0x21(%r12)
je 0x631f9
leaq 0x966cd(%rip), %rax     # 0xf98a8
cmpl $0x0, 0xa00(%rax)
jne 0x631f9
cmpb $0x2a, (%r15)
jne 0x631f9
cmpb $0x2d, 0x1(%r15)
je 0x631f9
movq %rbp, %rdi
callq 0x6281b
movl %r14d, (%rsp)
leaq 0x1c4(%rbx), %rax
cmpq %rax, %r15
je 0x63211
movq %r15, %rdi
callq 0x311c8
andq $0x0, 0x70(%rbx)
leaq 0xab1b3(%rip), %r15     # 0x10e3d0
jmp 0x63239
leaq 0x970ea(%rip), %rax     # 0xfa310
movq 0xe8(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbp, %rdi
callq 0x6270d
xorl %r14d, %r14d
movslq 0x38(%rbx), %rax
movq 0x40(%rbx), %rdi
cmpq %rax, %r14
jge 0x632fe
movq %r15, %r13
movq (%rdi,%r14,8), %r15
cmpq $0x1f, %r14
ja 0x632b7
cmpl $0x1, 0x4(%r15)
jne 0x632b7
movl (%r15), %eax
shrl $0x4, %eax
testb $0x7, %al
jne 0x632b7
movq 0x8(%r15), %r12
movq %r12, %rdi
callq 0x63370
cmpq $0x40, %rax
ja 0x632b7
movq (%r13), %rdi
testq %rdi, %rdi
je 0x6328b
callq 0x3a265
movq %r15, (%r13)
movq %r13, %r15
movzbl -0x1(%r12), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x632f2
leaq 0x5740b(%rip), %rdx     # 0xba6b4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x632f4
movq %r15, %rdi
callq 0x3a265
movq %r13, %r15
incq %r14
addq $0x8, 0x18(%rsp)
addq $0x8, %r15
jmp 0x6323c
movq -0x9(%r12), %rax
jmp 0x632f4
movzwl -0x3(%r12), %eax
jmp 0x632f4
movl -0x5(%r12), %eax
jmp 0x632f4
movzbl -0x2(%r12), %eax
jmp 0x632f4
xorl %eax, %eax
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
jmp 0x632c2
cmpq 0xab0bb(%rip), %rdi     # 0x10e3c0
je 0x6331b
callq 0x328f9
andq $0x0, 0xab0ac(%rip)     # 0x10e3c0
andl $0x0, 0xab0ad(%rip)     # 0x10e3c8
decl 0xab2af(%rip)           # 0x10e5d0
cmpl $0x0, (%rsp)
je 0x62b93
movq %rbp, %rdi
callq 0x627f7
jmp 0x62b96