// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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);
            } 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, %r13
callq 0x89969
cmpl $0x0, 0xa9c83(%rip)     # 0x11b570
je 0x7192b
leaq 0x5df84(%rip), %rsi     # 0xcf87a
leaq 0x5afe9(%rip), %r14     # 0xcc8e6
movl $0x3, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x32ea6
movq %r13, %rdi
movq %r14, %rsi
callq 0x71418
movl $0x1, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r14d
leaq 0x94f23(%rip), %rax     # 0x106858
movq 0x9c0(%rax), %rbx
movl $0x1, 0xa9c2a(%rip)     # 0x11b570
testl %r14d, %r14d
je 0x71abc
movl %r14d, %r12d
cmpl %r14d, 0xa9a0f(%rip)    # 0x11b368
jge 0x7197d
movq 0xa99fe(%rip), %rdi     # 0x11b360
leaq (,%r12,8), %rsi
callq 0x3b349
movq %rax, 0xa99ea(%rip)     # 0x11b360
movl %r14d, 0xa99eb(%rip)    # 0x11b368
testl %r14d, %r14d
movq %r13, 0x18(%rsp)
movq %rbx, (%rsp)
movl %ebp, 0x8(%rsp)
jle 0x71b01
movl %r14d, 0xc(%rsp)
leaq 0xa9ad1(%rip), %r14     # 0x11b470
leaq 0xa99ca(%rip), %rbx     # 0x11b370
xorl %ebp, %ebp
movq %rbp, %r15
incq %rbp
movq %r13, %rdi
movl %ebp, %esi
callq 0x89bc4
cmpl $0x3, %eax
jne 0x719ee
movq %r13, %rdi
movl %ebp, %esi
callq 0x89d7e
movl $0x40, %esi
leaq 0x20(%rsp), %r13
movq %r13, %rdi
leaq 0x5158c(%rip), %rdx     # 0xc2f67
movb $0x1, %al
callq 0x26120
cltq
movq %rax, 0x10(%rsp)
movq %r13, %rax
jmp 0x71a06
movq %r13, %rdi
movl %ebp, %esi
leaq 0x10(%rsp), %rdx
callq 0x89e02
testq %rax, %rax
je 0x71af2
cmpq $0x1f, %r15
ja 0x71a1e
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x71a1e
movq 0x10(%rsp), %rdx
cmpq %rdx, (%r14)
jae 0x71a51
movq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x43ba8
movq 0xa992e(%rip), %rcx     # 0x11b360
movq %rax, (%rcx,%r15,8)
addq $0x8, %r14
addq $0x8, %rbx
cmpq %rbp, %r12
movq 0x18(%rsp), %r13
jne 0x719a8
jmp 0x71aef
movq 0x8(%rcx), %r13
movq 0xa9904(%rip), %rsi     # 0x11b360
movq %rcx, (%rsi,%r15,8)
movq $0x0, (%rbx)
incq %rdx
movq %r13, %rdi
movq %rax, %rsi
callq 0x26c60
movzbl -0x1(%r13), %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x71a36
movq 0x10(%rsp), %rax
leaq 0x5abca(%rip), %rdx     # 0xcc658
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shlb $0x3, %al
movb %al, -0x1(%r13)
jmp 0x71a36
movq %rax, -0x11(%r13)
jmp 0x71a36
movw %ax, -0x5(%r13)
jmp 0x71a36
movl %eax, -0x9(%r13)
jmp 0x71a36
movb %al, -0x3(%r13)
jmp 0x71a36
leaq 0x5ae85(%rip), %rsi     # 0xcc948
movq %r13, %rdi
callq 0x71418
decl 0xa9a9f(%rip)           # 0x11b570
testl %ebp, %ebp
je 0x71917
movq %r13, %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7150d
movl %ebp, %r15d
movl 0x8(%rsp), %ebp
movq (%rsp), %rbx
movl 0xc(%rsp), %r14d
jmp 0x71b04
xorl %r15d, %r15d
cmpl %r14d, %r15d
leaq 0x94d4a(%rip), %r12     # 0x106858
jne 0x71c1a
movq 0xa9845(%rip), %rax     # 0x11b360
movq %rax, 0x40(%rbx)
movl %r14d, 0x38(%rbx)
cmpl $0x0, 0xa96da(%rip)     # 0x11b204
je 0x71bd5
cmpl $0x0, 0xa97f5(%rip)     # 0x11b32c
je 0x71bd5
movl %r14d, %r12d
leaq 0x5ae71(%rip), %rdi     # 0xcc9b8
callq 0x39245
movl 0x38(%rbx), %edx
testl %edx, %edx
jle 0x71bb3
leaq 0x5ae66(%rip), %r15     # 0xcc9c0
leaq 0x560d0(%rip), %r13     # 0xc7c31
xorl %ebx, %ebx
cmpq $0xa, %rbx
jne 0x71b7f
addl $-0xb, %edx
movq %rax, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x39eb7
movq (%rsp), %r14
jmp 0x71ba7
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x39a56
movq (%rsp), %r14
movq 0x40(%r14), %rcx
movq (%rcx,%rbx,8), %rcx
movq 0x8(%rcx), %rsi
movq %rax, %rdi
callq 0x39b4d
incq %rbx
movslq 0x38(%r14), %rdx
cmpq %rdx, %rbx
jl 0x71b63
movq 0xa9656(%rip), %rdi     # 0x11b210
movq %rax, %rsi
callq 0x2e40f
movq 0x18(%rsp), %r13
movq (%rsp), %rbx
movl %r12d, %r14d
leaq 0x94c83(%rip), %r12     # 0x106858
movq 0xa9784(%rip), %rax     # 0x11b360
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x35dc2
testq %rax, %rax
je 0x71c64
movq %rax, %r15
movl 0x10(%rax), %eax
testl %eax, %eax
setg %cl
cmpl %r14d, %eax
setne %dl
andb %cl, %dl
negl %eax
cmpl %eax, %r14d
setl %al
orb %dl, %al
cmpb $0x1, %al
jne 0x71c70
leaq 0x5adba(%rip), %rsi     # 0xcc9cf
jmp 0x72004
testl %r15d, %r15d
jle 0x71c3f
movl %r15d, %ebx
incq %rbx
movq 0xa9734(%rip), %rax     # 0x11b360
movq -0x10(%rax,%rbx,8), %rdi
callq 0x440f3
decq %rbx
cmpq $0x1, %rbx
jg 0x71c25
leaq 0x5ad38(%rip), %rsi     # 0xcc97e
movq %r13, %rdi
callq 0x71418
decl 0xa991c(%rip)           # 0x11b570
testl %ebp, %ebp
je 0x71917
movq %r13, %rdi
jmp 0x72147
leaq 0x5ad9f(%rip), %rsi     # 0xcca0a
jmp 0x72004
movq %r15, 0x50(%rbx)
movq %r15, 0x48(%rbx)
movl 0x20(%r15), %eax
testb $0x40, %al
jne 0x71d61
testb $0x1, %al
jne 0x71d6d
testb $0x4, %al
je 0x71cb4
cmpq $0x0, 0x8f8(%r12)
je 0x71cb4
cmpl $0x0, 0x9e8(%r12)
jne 0x71cb4
callq 0x36750
cmpl $-0x1, %eax
je 0x71ff2
movl 0x20(%r15), %eax
testb %al, %al
jns 0x71cc8
movl $0x1, 0x9ec(%r12)
testb $0x1, %al
je 0x71cd8
movl $0x1, 0x9e8(%r12)
cmpl $0x0, 0x98c(%r12)
je 0x71d93
cmpl $0x0, 0x31c(%r12)
jne 0x71d93
movq 0x9c8(%r12), %rax
testb $0x2, 0x98(%rax)
jne 0x71d93
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 0x705ec
movq 0x9a0(%r12), %rcx
cmpq (%rcx), %rax
je 0x71d93
leaq 0x5adbb(%rip), %rsi     # 0xccb17
jmp 0x72004
leaq 0x5accf(%rip), %rsi     # 0xcca37
jmp 0x72004
cmpl $0x0, 0x9ec(%r12)
je 0x71e05
cmpl $0x0, 0x9f0(%r12)
jne 0x71e05
leaq 0x5acd8(%rip), %rsi     # 0xcca66
jmp 0x72004
cmpl $0x0, 0x9f0(%r12)
je 0x71dd8
cmpl $0x0, 0x9f4(%r12)
jne 0x71dd8
cmpl $0x0, 0x9e8(%r12)
je 0x71dd8
cmpl $0x0, 0x9f8(%r12)
je 0x71dd8
movq 0x9c8(%r12), %rdi
callq 0x64871
movl $0x1, 0x9f4(%r12)
cmpl $0x0, 0x9f0(%r12)
je 0x71e8a
movl 0x9f8(%r12), %eax
movl %eax, %ecx
andl $0x1, %ecx
shll $0x2, %eax
andl $0x8, %eax
leal (%rax,%rcx,4), %esi
addl $0x3, %esi
jmp 0x71e8f
cmpq $0x0, 0x818(%r12)
je 0x71e4a
cmpl $0x0, 0x874(%r12)
je 0x71e4a
cmpl $0x0, 0x31c(%r12)
jne 0x71e4a
movq 0x9c8(%r12), %rcx
testb $0x2, 0x98(%rcx)
jne 0x71e4a
leaq 0x95472(%rip), %rax     # 0x1072b0
movq 0xc0(%rax), %rax
jmp 0x72000
cmpl $0x0, 0x774(%r12)
je 0x71c8c
cmpl $0x0, 0x730(%r12)
jle 0x71c8c
cmpl $-0x1, 0x770(%r12)
jne 0x71c8c
leaq 0x95432(%rip), %rax     # 0x1072b0
movq 0xb0(%rax), %rax
jmp 0x72000
movl $0x3, %esi
movq %rbx, %rdi
callq 0x35f45
movq 0x68(%rbx), %rax
cmpq $0x0, 0x28(%rax)
jne 0x71ecf
movslq 0x1c0(%rbx), %rax
cmpq $0x3fff, %rax           # imm = 0x3FFF
jg 0x71ecf
leaq 0x1c4(%rbx), %r12
movb $0x0, 0x1c4(%rbx,%rax)
movl $0x0, 0x1c0(%rbx)
jmp 0x71f67
leaq 0x1c4(%rbx), %rdi
movslq 0x1c0(%rbx), %rsi
callq 0x3910c
movq %rax, %r12
movl $0x0, 0x1c0(%rbx)
movq 0x68(%rbx), %rax
cmpq $0x0, 0x28(%rax)
je 0x71f67
leaq 0x5a76b(%rip), %rbx     # 0xcc66c
movq (%rsp), %r14
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 0x71f43
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x71f45
movq -0x11(%rsi), %rdx
jmp 0x71f45
movzwl -0x5(%rsi), %edx
jmp 0x71f45
movl -0x9(%rsi), %edx
jmp 0x71f45
movzbl -0x3(%rsi), %edx
jmp 0x71f45
xorl %edx, %edx
movq %r12, %rdi
callq 0x39a56
movq %rax, %r12
movq 0x68(%r14), %rdi
movq (%rdi), %rsi
callq 0x2e4f4
movq 0x68(%r14), %rax
cmpq $0x0, 0x28(%rax)
jne 0x71f05
testl %ebp, %ebp
je 0x71f77
xorl %eax, %eax
cmpb $0x2d, (%r12)
cmovnel %eax, %ebp
jmp 0x71f79
xorl %ebp, %ebp
movq (%rsp), %rbx
movq %r13, %rdi
movq %r12, %rsi
callq 0x71163
cmpl $0x0, 0xa9275(%rip)     # 0x11b204
je 0x71fa2
cmpl $0x0, 0xa9394(%rip)     # 0x11b32c
je 0x71fa2
movq %r12, %rdi
callq 0x72151
testb $0x1, 0x21(%r15)
je 0x71fd0
leaq 0x948a8(%rip), %rax     # 0x106858
cmpl $0x0, 0x9f0(%rax)
jne 0x71fd0
cmpb $0x2a, (%r12)
jne 0x71fd0
cmpb $0x2d, 0x1(%r12)
je 0x71fd0
movq %r13, %rdi
callq 0x71533
movl %ebp, 0x8(%rsp)
leaq 0x1c4(%rbx), %rax
cmpq %rax, %r12
je 0x71fe8
movq %r12, %rdi
callq 0x392b6
movq $0x0, 0x70(%rbx)
jmp 0x7200c
leaq 0x952b7(%rip), %rax     # 0x1072b0
movq 0xe8(%rax), %rax
movq 0x8(%rax), %rsi
movq %r13, %rdi
callq 0x71418
cmpl $0x0, 0x38(%rbx)
jle 0x7210a
xorl %r12d, %r12d
leaq 0xa9350(%rip), %r13     # 0x11b370
leaq 0x5a659(%rip), %rbp     # 0xcc680
xorl %r14d, %r14d
movq 0x40(%rbx), %rax
movq (%rax,%r12), %r15
cmpq $0x1f, %r14
ja 0x720c2
cmpl $0x1, 0x4(%r15)
jne 0x720c2
movl (%r15), %eax
shrl $0x4, %eax
testb $0x7, %al
jne 0x720c2
movq 0x8(%r15), %rbx
movzbl -0x1(%rbx), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x72085
movslq (%rbp,%rcx,4), %rcx
addq %rbp, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x72087
movq -0x11(%rbx), %rax
jmp 0x72087
movzwl -0x5(%rbx), %eax
jmp 0x72087
movl -0x9(%rbx), %eax
jmp 0x72087
movzbl -0x3(%rbx), %eax
jmp 0x72087
xorl %eax, %eax
cmpq $0x40, %rax
ja 0x720c2
movq (%r12,%r13), %rdi
testq %rdi, %rdi
je 0x7209b
callq 0x440f3
movq %r15, (%r12,%r13)
movzbl -0x1(%rbx), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x720fb
leaq 0x5a5e0(%rip), %rdx     # 0xcc694
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x720fd
movq %r15, %rdi
callq 0x440f3
movq (%rsp), %rbx
incq %r14
movslq 0x38(%rbx), %rax
addq $0x8, %r12
cmpq %rax, %r14
jl 0x7202a
jmp 0x7210a
movq -0x9(%rbx), %rax
jmp 0x720fd
movzwl -0x3(%rbx), %eax
jmp 0x720fd
movl -0x5(%rbx), %eax
jmp 0x720fd
movzbl -0x2(%rbx), %eax
jmp 0x720fd
xorl %eax, %eax
leaq 0xa936c(%rip), %rcx     # 0x11b470
movq %rax, (%r12,%rcx)
jmp 0x720ca
movq 0x40(%rbx), %rdi
cmpq 0xa924b(%rip), %rdi     # 0x11b360
je 0x72131
callq 0x3b3df
movq $0x0, 0xa9239(%rip) # 0x11b360
movl $0x0, 0xa9237(%rip)     # 0x11b368
decl 0xa9439(%rip)           # 0x11b570
cmpl $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
je 0x71917
callq 0x7150d
jmp 0x7191c