// File: /workspace/github_c_makefile_star2_O3/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 $0x68, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x85d4c
cmpl $0x0, 0xa87bb(%rip)     # 0x1165d0
je 0x6de53
leaq 0x5eb5c(%rip), %rsi     # 0xcc97a
leaq 0x5bb59(%rip), %r14     # 0xc997e
movl $0x3, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2fdad
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6d940
movl $0x1, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r14d
leaq 0x93a4b(%rip), %rax     # 0x1018a8
movq 0x9d0(%rax), %rax
movl $0x1, 0xa8762(%rip)     # 0x1165d0
testl %r14d, %r14d
je 0x6dff0
movq %rax, 0x10(%rsp)
movl %r14d, %r12d
cmpl %r14d, 0xa8542(%rip)    # 0x1163c8
jge 0x6deaa
movq 0xa8531(%rip), %rdi     # 0x1163c0
leaq (,%r12,8), %rsi
callq 0x3837d
movq %rax, 0xa851d(%rip)     # 0x1163c0
movl %r14d, 0xa851e(%rip)    # 0x1163c8
testl %r14d, %r14d
jle 0x6e26b
movl %r14d, 0xc(%rsp)
movl %ebp, 0x8(%rsp)
negq %r12
movl $0x1, %r15d
xorl %r14d, %r14d
leaq 0x20(%rsp), %rbp
movq %rbx, %rdi
movl %r15d, %esi
callq 0x860ba
movq %rbx, %rdi
movl %r15d, %esi
cmpl $0x3, %eax
jne 0x6df0a
callq 0x86274
movl $0x40, %esi
movq %rbp, %rdi
leaq 0x520b8(%rip), %rdx     # 0xbffaf
movb $0x1, %al
callq 0x26120
cltq
movq %rax, 0x18(%rsp)
movq %rbp, %rax
jmp 0x6df1d
leaq 0x18(%rsp), %rdx
callq 0x862f8
testq %rax, %rax
je 0x6e023
leaq -0x1(%r15), %rcx
cmpq $0x20, %rcx
jae 0x6dfa1
leaq 0xa84a2(%rip), %rcx     # 0x1163d0
movq (%r14,%rcx), %rcx
movq 0x18(%rsp), %rdx
testq %rcx, %rcx
je 0x6dfa6
leaq 0xa858d(%rip), %rsi     # 0x1164d0
cmpq %rdx, (%r14,%rsi)
jb 0x6dfa6
movq 0x8(%rcx), %r13
movq 0xa846c(%rip), %rsi     # 0x1163c0
movq %rcx, -0x8(%rsi,%r15,8)
leaq 0xa8470(%rip), %rcx     # 0x1163d0
movq $0x0, (%r14,%rcx)
incq %rdx
movq %r13, %rdi
movq %rax, %rsi
callq 0x26c50
movzbl -0x1(%r13), %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x6dfbd
movq 0x18(%rsp), %rax
leaq 0x5b755(%rip), %rdx     # 0xc96e4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shlb $0x3, %al
movb %al, -0x1(%r13)
jmp 0x6dfbd
movq 0x18(%rsp), %rdx
movq %rax, %rdi
movq %rdx, %rsi
callq 0x40744
movq 0xa8408(%rip), %rcx     # 0x1163c0
movq %rax, -0x8(%rcx,%r15,8)
addq $0x8, %r14
leaq (%r12,%r15), %rax
incq %rax
incq %r15
cmpq $0x1, %rax
jne 0x6decd
jmp 0x6e033
movq %rax, -0x11(%r13)
jmp 0x6dfbd
movw %ax, -0x5(%r13)
jmp 0x6dfbd
movl %eax, -0x9(%r13)
jmp 0x6dfbd
movb %al, -0x3(%r13)
jmp 0x6dfbd
leaq 0x5b9e9(%rip), %rsi     # 0xc99e0
movq %rbx, %rdi
callq 0x6d940
decl 0xa85cb(%rip)           # 0x1165d0
testl %ebp, %ebp
je 0x6de3f
movq %rbx, %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6da35
movl %r15d, %eax
subl 0xc(%rsp), %eax
cmpl $0x1, %eax
jne 0x6e247
movq 0xa8386(%rip), %rax     # 0x1163c0
movq 0x10(%rsp), %r12
movq %rax, 0x40(%r12)
movl 0xc(%rsp), %ecx
movl %ecx, 0x38(%r12)
cmpl $0x0, 0xa8210(%rip)     # 0x116264
je 0x6e0fb
cmpl $0x0, 0xa832b(%rip)     # 0x11638c
leaq 0x93840(%rip), %r14     # 0x1018a8
je 0x6e102
leaq 0x5b9db(%rip), %rdi     # 0xc9a50
callq 0x362b0
cmpl $0x0, 0x38(%r12)
jle 0x6e0e3
movl $0x1, %r14d
leaq 0x56c0e(%rip), %r15     # 0xc4c9d
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x36ad1
movq 0x40(%r12), %rcx
movq -0x8(%rcx,%r14,8), %rcx
movq 0x8(%rcx), %rsi
movq %rax, %rdi
callq 0x36bc3
movslq 0x38(%r12), %rdx
cmpq %rdx, %r14
jge 0x6e0dc
incq %r14
cmpq $0xb, %r14
jne 0x6e08f
addl $-0xb, %edx
leaq 0x5b986(%rip), %rsi     # 0xc9a58
movq %rax, %rdi
xorl %eax, %eax
callq 0x36f2d
leaq 0x937c5(%rip), %r14     # 0x1018a8
movq 0xa8186(%rip), %rdi     # 0x116270
movq %rax, %rsi
callq 0x2b24b
movq 0xa82c7(%rip), %rax     # 0x1163c0
jmp 0x6e102
leaq 0x937a6(%rip), %r14     # 0x1018a8
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x32d3c
testq %rax, %rax
je 0x6e142
movq %rax, %r15
movl 0x10(%rax), %eax
testl %eax, %eax
setg %cl
movl 0xc(%rsp), %esi
cmpl %esi, %eax
setne %dl
andb %cl, %dl
negl %eax
cmpl %eax, %esi
setl %al
orb %dl, %al
cmpb $0x1, %al
jne 0x6e14e
leaq 0x5b92a(%rip), %rsi     # 0xc9a67
jmp 0x6e536
leaq 0x5b959(%rip), %rsi     # 0xc9aa2
jmp 0x6e536
movq %r15, 0x50(%r12)
movq %r15, 0x48(%r12)
movl 0x20(%r15), %eax
testb $0x40, %al
jne 0x6e28d
testb $0x1, %al
jne 0x6e299
testb $0x4, %al
je 0x6e196
cmpq $0x0, 0x908(%r14)
je 0x6e196
cmpl $0x0, 0x9f8(%r14)
jne 0x6e196
callq 0x336e5
cmpl $-0x1, %eax
je 0x6e524
movl 0x20(%r15), %eax
testb %al, %al
jns 0x6e1a5
movl $0x1, 0x9fc(%r14)
testb $0x1, %al
je 0x6e1b4
movl $0x1, 0x9f8(%r14)
cmpl $0x0, 0x99c(%r14)
je 0x6e2bd
cmpl $0x0, 0x31c(%r14)
jne 0x6e2bd
movq 0x9d8(%r14), %rax
testb $0x2, 0x98(%rax)
jne 0x6e2bd
movl $0xfffdfdff, %ecx       # imm = 0xFFFDFDFF
andl 0x98(%r12), %ecx
movl %ecx, 0x98(%r12)
movl $0x20200, %edx          # imm = 0x20200
andl 0x98(%rax), %edx
orl %ecx, %edx
movl %edx, 0x98(%r12)
movq 0x48(%r12), %rsi
movq 0x40(%r12), %rdx
movl 0x38(%r12), %ecx
movq %r12, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6cae4
movq 0x9b0(%r14), %rcx
cmpq (%rcx), %rax
je 0x6e2bd
leaq 0x5b96d(%rip), %rsi     # 0xc9baf
jmp 0x6e536
cmpq $0x1, %r15
movl 0x8(%rsp), %ebp
je 0x6e26b
movq 0xa8168(%rip), %rax     # 0x1163c0
movq -0x10(%rax,%r15,8), %rdi
callq 0x40c8f
decq %r15
cmpq $0x1, %r15
ja 0x6e251
leaq 0x5b7a4(%rip), %rsi     # 0xc9a16
movq %rbx, %rdi
callq 0x6d940
decl 0xa8350(%rip)           # 0x1165d0
testl %ebp, %ebp
jne 0x6e695
jmp 0x6de3f
leaq 0x5b83b(%rip), %rsi     # 0xc9acf
jmp 0x6e536
cmpl $0x0, 0x9fc(%r14)
je 0x6e329
cmpl $0x0, 0xa00(%r14)
jne 0x6e329
leaq 0x5b846(%rip), %rsi     # 0xc9afe
jmp 0x6e536
movl 0xa00(%r14), %eax
testl %eax, %eax
je 0x6e304
cmpl $0x0, 0xa04(%r14)
jne 0x6e304
cmpl $0x0, 0x9f8(%r14)
je 0x6e304
cmpl $0x0, 0xa08(%r14)
je 0x6e304
movq 0x9d8(%r14), %rdi
callq 0x60c81
movl $0x1, 0xa04(%r14)
movl 0xa00(%r14), %eax
testl %eax, %eax
je 0x6e3a7
movl 0xa08(%r14), %eax
movl %eax, %ecx
andl $0x1, %ecx
shll $0x2, %eax
andl $0x8, %eax
leal (%rax,%rcx,4), %esi
addl $0x3, %esi
jmp 0x6e3ac
cmpq $0x0, 0x828(%r14)
je 0x6e36a
cmpl $0x0, 0x884(%r14)
je 0x6e36a
cmpl $0x0, 0x31c(%r14)
jne 0x6e36a
movq 0x9d8(%r14), %rcx
testb $0x2, 0x98(%rcx)
jne 0x6e36a
leaq 0x93fb2(%rip), %rax     # 0x102310
movq 0xc0(%rax), %rax
jmp 0x6e532
cmpl $0x0, 0x784(%r14)
je 0x6e16c
cmpl $0x0, 0x740(%r14)
jle 0x6e16c
cmpl $-0x1, 0x780(%r14)
jne 0x6e16c
leaq 0x93f75(%rip), %rax     # 0x102310
movq 0xb0(%rax), %rax
jmp 0x6e532
movl $0x3, %esi
movq %r12, %rdi
callq 0x32eba
movq 0x68(%r12), %rax
cmpq $0x0, 0x28(%rax)
sete %al
movl 0x1c0(%r12), %ecx
movslq %ecx, %rsi
cmpl $0x4000, %esi           # imm = 0x4000
setl %cl
andb %al, %cl
movq %r12, %r14
addq $0x1c4, %r12            # imm = 0x1C4
cmpb $0x1, %cl
jne 0x6e3ff
movb $0x0, 0x1c4(%r14,%rsi)
movl $0x0, 0x1c0(%r14)
jmp 0x6e48e
movq %r12, %rdi
callq 0x36178
movq %rax, %r12
movl $0x0, 0x1c0(%r14)
movq 0x68(%r14), %rax
cmpq $0x0, 0x28(%rax)
je 0x6e48e
leaq 0x5b2d1(%rip), %r14     # 0xc96f8
movq 0x10(%rsp), %r13
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x6e46a
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x6e46c
movq -0x11(%rsi), %rdx
jmp 0x6e46c
movzwl -0x5(%rsi), %edx
jmp 0x6e46c
movl -0x9(%rsi), %edx
jmp 0x6e46c
movzbl -0x3(%rsi), %edx
jmp 0x6e46c
xorl %edx, %edx
movq %r12, %rdi
callq 0x36ad1
movq %rax, %r12
movq 0x68(%r13), %rdi
movq (%rdi), %rsi
callq 0x2b331
movq 0x68(%r13), %rax
cmpq $0x0, 0x28(%rax)
jne 0x6e42c
movl 0x8(%rsp), %ebp
testl %ebp, %ebp
je 0x6e4a2
xorl %eax, %eax
cmpb $0x2d, (%r12)
cmovnel %eax, %ebp
jmp 0x6e4a4
xorl %ebp, %ebp
leaq 0x933fd(%rip), %r14     # 0x1018a8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6d68b
cmpl $0x0, 0xa7da7(%rip)     # 0x116264
je 0x6e4d0
cmpl $0x0, 0xa7ec6(%rip)     # 0x11638c
je 0x6e4d0
movq %r12, %rdi
callq 0x6e6a2
testb $0x1, 0x21(%r15)
je 0x6e4f8
cmpl $0x0, 0xa00(%r14)
jne 0x6e4f8
cmpb $0x2a, (%r12)
jne 0x6e4f8
cmpb $0x2d, 0x1(%r12)
je 0x6e4f8
movq %rbx, %rdi
callq 0x6da5b
movl %ebp, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x1c4, %rax            # imm = 0x1C4
cmpq %rax, %r12
je 0x6e514
movq %r12, %rdi
callq 0x36330
movq 0x10(%rsp), %r12
movq $0x0, 0x70(%r12)
jmp 0x6e53e
leaq 0x93de5(%rip), %rax     # 0x102310
movq 0xe8(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x6d940
cmpl $0x0, 0x38(%r12)
jle 0x6e65c
xorl %r14d, %r14d
leaq 0x5b1b8(%rip), %r13     # 0xc970c
xorl %ebp, %ebp
movq 0x40(%r12), %rax
movq (%rax,%r14), %r15
cmpq $0x1f, %rbp
ja 0x6e60b
cmpl $0x1, 0x4(%r15)
jne 0x6e60b
movl (%r15), %eax
shrl $0x4, %eax
testb $0x7, %al
jne 0x6e60b
movq 0x8(%r15), %r12
movzbl -0x1(%r12), %eax
movl %eax, %ecx
andl $0x7, %ecx
decl %ecx
cmpl $0x3, %ecx
ja 0x6e5c4
movslq (%r13,%rcx,4), %rcx
addq %r13, %rcx
jmpq *%rcx
movzbl -0x3(%r12), %ecx
jmp 0x6e5be
movl -0x9(%r12), %ecx
jmp 0x6e5be
movq -0x11(%r12), %rcx
jmp 0x6e5be
movzwl -0x5(%r12), %ecx
cmpq $0x40, %rcx
ja 0x6e60b
leaq 0xa7e05(%rip), %rcx     # 0x1163d0
movq (%r14,%rcx), %rdi
testq %rdi, %rdi
je 0x6e5de
callq 0x40c8f
movb -0x1(%r12), %al
leaq 0xa7deb(%rip), %rcx     # 0x1163d0
movq %r15, (%r14,%rcx)
movzbl %al, %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x6e64d
leaq 0x5b11f(%rip), %rdx     # 0xc971c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x6e64f
movq %r15, %rdi
callq 0x40c8f
movq 0x10(%rsp), %r12
incq %rbp
movslq 0x38(%r12), %rax
addq $0x8, %r14
cmpq %rax, %rbp
jl 0x6e556
jmp 0x6e65c
movq -0x9(%r12), %rax
jmp 0x6e64f
movzwl -0x3(%r12), %eax
jmp 0x6e64f
movl -0x5(%r12), %eax
jmp 0x6e64f
movzbl -0x2(%r12), %eax
jmp 0x6e64f
xorl %eax, %eax
leaq 0xa7e7a(%rip), %rcx     # 0x1164d0
movq %rax, (%r14,%rcx)
jmp 0x6e613
movq 0x40(%r12), %rdi
cmpq 0xa7d58(%rip), %rdi     # 0x1163c0
je 0x6e684
callq 0x38413
movq $0x0, 0xa7d46(%rip) # 0x1163c0
movl $0x0, 0xa7d44(%rip)     # 0x1163c8
decl 0xa7f46(%rip)           # 0x1165d0
cmpl $0x0, 0x8(%rsp)
je 0x6de3f
movq %rbx, %rdi
callq 0x6da35
jmp 0x6de44