// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_InfoCoreCommand
static int Jim_InfoCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr;
    int mode = 0;


    enum {
        INFO_ALIAS,
        INFO_ARGS,
        INFO_BODY,
        INFO_CHANNELS,
        INFO_COMMANDS,
        INFO_COMPLETE,
        INFO_EXISTS,
        INFO_FRAME,
        INFO_GLOBALS,
        INFO_HOSTNAME,
        INFO_LEVEL,
        INFO_LOCALS,
        INFO_NAMEOFEXECUTABLE,
        INFO_PATCHLEVEL,
        INFO_PROCS,
        INFO_REFERENCES,
        INFO_RETURNCODES,
        INFO_SCRIPT,
        INFO_SOURCE,
        INFO_STACKTRACE,
        INFO_STATICS,
        INFO_VARS,
        INFO_VERSION,
        INFO_COUNT
    };
    static const jim_subcmd_type cmds[INFO_COUNT + 1] = {
        JIM_DEF_SUBCMD("alias", "command", 1, 1),
        JIM_DEF_SUBCMD("args", "procname", 1, 1),
        JIM_DEF_SUBCMD("body", "procname", 1, 1),
        JIM_DEF_SUBCMD("channels", "?pattern?", 0, 1),
        JIM_DEF_SUBCMD("commands", "?pattern?", 0, 1),
        JIM_DEF_SUBCMD("complete", "script ?missing?", 1, 2),
        JIM_DEF_SUBCMD("exists", "varName", 1, 1),
        JIM_DEF_SUBCMD("frame", "?levelNum?", 0, 1),
        JIM_DEF_SUBCMD("globals", "?pattern?", 0, 1),
        JIM_DEF_SUBCMD("hostname", NULL, 0, 0),
        JIM_DEF_SUBCMD("level", "?levelNum?", 0, 1),
        JIM_DEF_SUBCMD("locals", "?pattern?", 0, 1),
        JIM_DEF_SUBCMD("nameofexecutable", NULL, 0, 0),
        JIM_DEF_SUBCMD("patchlevel", NULL, 0, 0),
        JIM_DEF_SUBCMD("procs", "?pattern?", 0, 1),
        JIM_DEF_SUBCMD("references", NULL, 0, 0),
        JIM_DEF_SUBCMD("returncodes", "?code?", 0, 1),
        JIM_DEF_SUBCMD("script", "?filename?", 0, 1),
        JIM_DEF_SUBCMD("source", "source ?filename line?", 1, 3),
        JIM_DEF_SUBCMD("stacktrace", NULL, 0, 0),
        JIM_DEF_SUBCMD("statics", "procname", 1, 1),
        JIM_DEF_SUBCMD("vars", "?pattern?", 0, 1),
        JIM_DEF_SUBCMD("version", NULL, 0, 0),
        { NULL }
    };
    const jim_subcmd_type *ct;
#ifdef jim_ext_namespace
    int nons = 0;

    if (argc > 2 && Jim_CompareStringImmediate(interp, argv[1], "-nons")) {

        argc--;
        argv++;
        nons = 1;
    }
#endif
    ct = Jim_ParseSubCmd(interp, cmds, argc, argv);
    if (!ct) {
        return JIM_ERR;
    }
    if (ct->function) {

        return ct->function(interp, argc, argv);
    }

    int option = ct - cmds;

    switch (option) {
        case INFO_EXISTS:
            Jim_SetResultBool(interp, Jim_GetVariable(interp, argv[2], 0) != NULL);
            return JIM_OK;

        case INFO_ALIAS:{
            Jim_Cmd *cmdPtr;

            if ((cmdPtr = Jim_GetCommand(interp, argv[2], JIM_ERRMSG)) == NULL) {
                return JIM_ERR;
            }
            if (cmdPtr->isproc || cmdPtr->u.native.cmdProc != JimAliasCmd) {
                Jim_SetResultFormatted(interp, "command \"%#s\" is not an alias", argv[2]);
                return JIM_ERR;
            }
            Jim_SetResult(interp, (Jim_Obj *)cmdPtr->u.native.privData);
            return JIM_OK;
        }

        case INFO_CHANNELS:
            mode++;
#ifndef jim_ext_aio
            Jim_SetResultString(interp, "aio not enabled", -1);
            return JIM_ERR;
#endif

        case INFO_PROCS:
            mode++;

        case INFO_COMMANDS:

#ifdef jim_ext_namespace
            if (!nons) {
                if (Jim_Length(interp->framePtr->nsObj) || (argc == 3 && JimIsGlobalNamespace(argv[2]))) {
                    return Jim_EvalPrefix(interp, "namespace info", argc - 1, argv + 1);
                }
            }
#endif
            Jim_SetResult(interp, JimCommandsList(interp, (argc == 3) ? argv[2] : NULL, mode));
            return JIM_OK;

        case INFO_VARS:
            mode++;

        case INFO_LOCALS:
            mode++;

        case INFO_GLOBALS:

#ifdef jim_ext_namespace
            if (!nons) {
                if (Jim_Length(interp->framePtr->nsObj) || (argc == 3 && JimIsGlobalNamespace(argv[2]))) {
                    return Jim_EvalPrefix(interp, "namespace info", argc - 1, argv + 1);
                }
            }
#endif
            Jim_SetResult(interp, JimVariablesList(interp, argc == 3 ? argv[2] : NULL, mode));
            return JIM_OK;

        case INFO_SCRIPT:
            if (argc == 3) {
                Jim_IncrRefCount(argv[2]);
                Jim_DecrRefCount(interp, interp->currentFilenameObj);
                interp->currentFilenameObj = argv[2];
            }
            Jim_SetResult(interp, interp->currentFilenameObj);
            return JIM_OK;

        case INFO_SOURCE:{
                Jim_Obj *resObjPtr;
                Jim_Obj *fileNameObj;

                if (argc == 4) {
                    Jim_SubCmdArgError(interp, ct, argv[0]);
                    return JIM_ERR;
                }
                if (argc == 5) {
                    jim_wide line;
                    if (Jim_GetWide(interp, argv[4], &line) != JIM_OK) {
                        return JIM_ERR;
                    }
                    resObjPtr = Jim_NewStringObj(interp, Jim_String(argv[2]), Jim_Length(argv[2]));
                    Jim_SetSourceInfo(interp, resObjPtr, argv[3], line);
                }
                else {
                    int line;
                    fileNameObj = Jim_GetSourceInfo(interp, argv[2], &line);
                    resObjPtr = Jim_NewListObj(interp, NULL, 0);
                    Jim_ListAppendElement(interp, resObjPtr, fileNameObj);
                    Jim_ListAppendElement(interp, resObjPtr, Jim_NewIntObj(interp, line));
                }
                Jim_SetResult(interp, resObjPtr);
                return JIM_OK;
            }

        case INFO_STACKTRACE:
            Jim_SetResult(interp, interp->stackTrace);
            return JIM_OK;

        case INFO_LEVEL:
            if (argc == 2) {
                Jim_SetResultInt(interp, interp->framePtr->level);
            }
            else {
                if (JimInfoLevel(interp, argv[2], &objPtr) != JIM_OK) {
                    return JIM_ERR;
                }
                Jim_SetResult(interp, objPtr);
            }
            return JIM_OK;

        case INFO_FRAME:
            if (argc == 2) {
                Jim_SetResultInt(interp, interp->procLevel + 1);
            }
            else {
                if (JimInfoFrame(interp, argv[2], &objPtr) != JIM_OK) {
                    return JIM_ERR;
                }
                Jim_SetResult(interp, objPtr);
            }
            return JIM_OK;

        case INFO_BODY:
        case INFO_STATICS:
        case INFO_ARGS:{
                Jim_Cmd *cmdPtr;

                if ((cmdPtr = Jim_GetCommand(interp, argv[2], JIM_ERRMSG)) == NULL) {
                    return JIM_ERR;
                }
                if (!cmdPtr->isproc) {
                    Jim_SetResultFormatted(interp, "command \"%#s\" is not a procedure", argv[2]);
                    return JIM_ERR;
                }
                switch (option) {
#ifdef JIM_NO_INTROSPECTION
                    default:
                        Jim_SetResultString(interp, "unsupported", -1);
                        return JIM_ERR;
#else
                    case INFO_BODY:
                        Jim_SetResult(interp, cmdPtr->u.proc.bodyObjPtr);
                        break;
                    case INFO_ARGS:
                        Jim_SetResult(interp, cmdPtr->u.proc.argListObjPtr);
                        break;
#endif
                    case INFO_STATICS:
                        if (cmdPtr->u.proc.staticVars) {
                            Jim_SetResult(interp, JimHashtablePatternMatch(interp, cmdPtr->u.proc.staticVars,
                                NULL, JimVariablesMatch, JIM_VARLIST_LOCALS | JIM_VARLIST_VALUES));
                        }
                        break;
                }
                return JIM_OK;
            }

        case INFO_VERSION:
        case INFO_PATCHLEVEL:{
                char buf[(JIM_INTEGER_SPACE * 2) + 1];

                sprintf(buf, "%d.%d", JIM_VERSION / 100, JIM_VERSION % 100);
                Jim_SetResultString(interp, buf, -1);
                return JIM_OK;
            }

        case INFO_COMPLETE: {
                char missing;

                Jim_SetResultBool(interp, Jim_ScriptIsComplete(interp, argv[2], &missing));
                if (missing != ' ' && argc == 4) {
                    Jim_SetVariable(interp, argv[3], Jim_NewStringObj(interp, &missing, 1));
                }
                return JIM_OK;
            }

        case INFO_HOSTNAME:

            return Jim_Eval(interp, "os.gethostname");

        case INFO_NAMEOFEXECUTABLE:

            return Jim_Eval(interp, "{info nameofexecutable}");

        case INFO_RETURNCODES:
            if (argc == 2) {
                int i;
                Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0);

                for (i = 0; jimReturnCodes[i]; i++) {
                    Jim_ListAppendElement(interp, listObjPtr, Jim_NewIntObj(interp, i));
                    Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp,
                            jimReturnCodes[i], -1));
                }

                Jim_SetResult(interp, listObjPtr);
            }
            else if (argc == 3) {
                long code;
                const char *name;

                if (Jim_GetLong(interp, argv[2], &code) != JIM_OK) {
                    return JIM_ERR;
                }
                name = Jim_ReturnCode(code);
                if (*name == '?') {
                    Jim_SetResultInt(interp, code);
                }
                else {
                    Jim_SetResultString(interp, name, -1);
                }
            }
            return JIM_OK;
        case INFO_REFERENCES:
#ifdef JIM_REFERENCES
            return JimInfoReferences(interp, argc, argv);
#else
            Jim_SetResultString(interp, "not supported", -1);
            return JIM_ERR;
#endif
        default:
            abort();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x178c1(%rip), %r13     # 0x379a0
movq %r13, %rsi
movl %r12d, %edx
movq %r15, %rcx
callq 0x11bb6
movl $0x1, %edi
testq %rax, %rax
je 0x2062d
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x2011d
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
movq %rax, %r14
subq %r13, %r14
shrq $0x5, %r14
cmpl $0x16, %r14d
ja 0x20906
xorl %r8d, %r8d
movl %r14d, %ecx
leaq 0x845e(%rip), %rdx      # 0x2859c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x67d1
testq %rax, %rax
je 0x205cc
cmpl $0x0, 0x4(%rax)
je 0x205b7
xorl %edi, %edi
cmpl $0x1, %r14d
je 0x20714
cmpl $0x14, %r14d
je 0x206eb
cmpl $0x2, %r14d
jne 0x2062d
movq 0x20(%rax), %r14
jmp 0x20718
leaq 0xdfb1(%rip), %rsi      # 0x2e14c
leaq -0x70(%rbp), %r15
movq %r15, %rdi
xorl %edx, %edx
movl $0x54, %ecx
xorl %eax, %eax
callq 0x6480
movq %rbx, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r15
incl 0x10(%rax)
jmp 0x2022e
cmpl $0x2, %r12d
jne 0x205d3
movq 0x58(%rbx), %rax
movslq 0x8(%rax), %r15
jmp 0x203d0
movl $0x1, %r8d
jmp 0x204fa
movb $0x1, %al
jmp 0x204fc
movq 0x10(%r15), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98ef
xorl %r14d, %r14d
testq %rax, %rax
setne %r14b
movq %rbx, %rdi
callq 0xae58
movq %rax, %r15
leaq 0x160c5(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
movq %r14, 0x18(%r15)
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x20247
movq %rbx, %rdi
callq 0x759a
movq %r15, (%rbx)
jmp 0x2062b
leaq 0xe148(%rip), %rsi      # 0x2e39e
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r15
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x20282
movq %rbx, %rdi
callq 0x759a
movq %r15, (%rbx)
jmp 0x205cc
movl $0x2, %r8d
jmp 0x2058e
leaq 0xdec5(%rip), %rsi      # 0x2e161
jmp 0x203a6
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0xb66b
movl 0x24(%rax), %ecx
cmpl $0x20, %ecx
sete %al
movl %ecx, -0x2c(%rbp)
cmpl $0x7d, %ecx
sete %cl
orb %al, %cl
movzbl %cl, %r13d
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x16009(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r13, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x20303
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %edi, %edi
cmpl $0x4, %r12d
jne 0x2062d
movl -0x2c(%rbp), %r14d
cmpb $0x20, %r14b
je 0x2062d
movq 0x18(%r15), %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r12
movl $0x2, %esi
xorl %edi, %edi
callq *0x17f4c(%rip)          # 0x38288
movb %r14b, (%rax)
movb $0x0, 0x1(%rax)
movq %rax, (%r12)
movl $0x1, 0x14(%r12)
movq $0x0, 0x8(%r12)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x871b
jmp 0x2062b
cmpl $0x5, %r12d
je 0x2063e
cmpl $0x4, %r12d
jne 0x206b1
movq (%r15), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11ab3
jmp 0x205cc
movq 0x188(%rbx), %r14
jmp 0x2060b
leaq 0xddac(%rip), %rsi      # 0x2e152
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1102e
cmpl $0x2, %r12d
jne 0x205e5
movslq 0x110(%rbx), %r15
incq %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x15efe(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jl 0x20620
jmp 0x20628
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x67d1
testq %rax, %rax
je 0x205cc
cmpl $0x0, 0x4(%rax)
jne 0x20440
leaq 0x1fb3(%rip), %rcx      # 0x223e9
cmpq %rcx, 0x18(%rax)
je 0x20817
movq 0x10(%r15), %rdx
leaq 0xdcc2(%rip), %rsi      # 0x2e10d
jmp 0x205c2
cmpl $0x3, %r12d
je 0x20678
movl $0x0, %edi
cmpl $0x2, %r12d
jne 0x2062d
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x15edd(%rip), %rax     # 0x36358
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
leaq 0x15f3b(%rip), %r15     # 0x363d0
xorl %r12d, %r12d
leaq 0x15e41(%rip), %r13     # 0x362e0
movq %rbx, %rdi
callq 0xae58
movq %r13, 0x8(%rax)
movq $0x0, (%rax)
movq %r12, 0x18(%rax)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7695
movq (%r15), %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7695
incq %r12
addq $0x8, %r15
cmpq $0x8, %r12
jne 0x2049f
jmp 0x2060b
movl $0x2, %r8d
xorl %eax, %eax
cmpl $0x3, %r12d
jne 0x20508
movq 0x10(%r15), %rdx
jmp 0x2050a
xorl %edx, %edx
movl $0x60, %ecx
testl %r8d, %r8d
je 0x20531
cmpl $0x1, %r8d
jne 0x2052c
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
je 0x20604
testb %al, %al
jne 0x20531
movl $0x58, %ecx
movq (%rbx,%rcx), %rsi
addq $0x10, %rsi
leaq 0x4eb3(%rip), %rcx      # 0x253f3
movq %rbx, %rdi
callq 0x252e7
movq %rax, %r14
jmp 0x2060b
cmpl $0x3, %r12d
jne 0x2057f
movq 0x10(%r15), %rax
incl 0x10(%rax)
movq 0x10(%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x20577
movq %rbx, %rdi
callq 0x759a
movq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %r14
jmp 0x2060b
movl $0x1, %r8d
cmpl $0x3, %r12d
jne 0x2059a
movq 0x10(%r15), %rdx
jmp 0x2059c
xorl %edx, %edx
leaq 0x68(%rbx), %rsi
leaq 0x4ed1(%rip), %rcx      # 0x25478
movq %rbx, %rdi
callq 0x252e7
movq %rax, %r14
incl 0x10(%rax)
jmp 0x2060f
movq 0x10(%r15), %rdx
leaq 0xdb69(%rip), %rsi      # 0x2e12b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x692d
movl $0x1, %edi
jmp 0x2062d
movq 0x10(%r15), %rsi
leaq -0x70(%rbp), %rdx
movq %rbx, %rdi
callq 0x24fa6
jmp 0x205f5
movq 0x10(%r15), %rsi
leaq -0x70(%rbp), %rdx
movq %rbx, %rdi
callq 0x25064
movl $0x1, %edi
testl %eax, %eax
jne 0x2062d
movq -0x70(%rbp), %r14
jmp 0x2060b
movq 0x128(%rbx), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x20628
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %edi, %edi
movl %edi, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%r15), %r12
leaq 0x15c97(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r12)
je 0x2073f
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0xd6d7
movl $0x1, %edi
testl %eax, %eax
je 0x2073f
xorl %eax, %eax
jmp 0x20746
movq 0x10(%r15), %r15
leaq 0x15c5d(%rip), %r12     # 0x362e0
cmpq %r12, 0x8(%r15)
je 0x207e6
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6d7
movl $0x1, %edi
testl %eax, %eax
je 0x207e6
xorl %eax, %eax
jmp 0x207ec
movq 0x10(%r15), %rax
movq 0x8(%rax), %rcx
leaq 0x15b18(%rip), %rdx     # 0x361d8
cmpq %rdx, %rcx
je 0x2080d
leaq 0x15b30(%rip), %rdx     # 0x36200
cmpq %rdx, %rcx
je 0x20820
leaq 0x128(%rbx), %rax
movl $0x1, %r15d
jmp 0x20833
movq 0x28(%rax), %rsi
testq %rsi, %rsi
je 0x2062d
leaq 0x4cf4(%rip), %rcx      # 0x253f3
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1001, %r8d           # imm = 0x1001
callq 0x252e7
jmp 0x201c0
movq 0x18(%rax), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x20737
movq %rbx, %rdi
callq 0x759a
xorl %edi, %edi
movq %r14, (%rbx)
jmp 0x2062d
movl 0x18(%r12), %r14d
movb $0x1, %al
testb %al, %al
je 0x207d9
movl %eax, -0x2c(%rbp)
movq 0x10(%r15), %r12
cmpq $0x0, (%r12)
jne 0x20767
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movl %r14d, -0x30(%rbp)
movq (%r12), %r12
movq 0x10(%r15), %r13
cmpq $0x0, (%r13)
jne 0x20784
movq 0x8(%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
movl 0x14(%r13), %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7516
movq %rax, %r12
movq 0x18(%r15), %r14
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x207b4
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x207b4
movq %rbx, %rdi
movq %r12, %rsi
callq *%rax
incl 0x10(%r14)
movq %r14, 0x18(%r12)
movl -0x30(%rbp), %eax
movl %eax, 0x20(%r12)
leaq 0x15a0c(%rip), %rax     # 0x361d8
movq %rax, 0x8(%r12)
movl $0x1, %edi
movl -0x2c(%rbp), %eax
testb %al, %al
je 0x2062d
jmp 0x20896
movq 0x18(%r15), %r15
movb $0x1, %al
testb %al, %al
je 0x2062d
testl $0xfffffff8, %r15d      # imm = 0xFFFFFFF8
je 0x208bc
leaq 0xbc61(%rip), %rsi      # 0x2c469
jmp 0x208cd
movl 0x20(%rax), %r15d
addq $0x18, %rax
jmp 0x20833
movq 0x28(%rax), %r14
jmp 0x2060b
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb66b
movl 0x1c(%rax), %r15d
addq $0x8, %rax
movq (%rax), %r14
movq %rbx, %rdi
callq 0xae58
movq %rax, %r12
leaq 0x15b10(%rip), %rax     # 0x36358
movq %rax, 0x8(%r12)
xorl %r13d, %r13d
movq %r13, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x7695
movslq %r15d, %r14
movq %rbx, %rdi
callq 0xae58
leaq 0x15a63(%rip), %rcx     # 0x362e0
movq %rcx, 0x8(%rax)
movq %r13, (%rax)
movq %r14, 0x18(%rax)
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x7695
incl 0x10(%r12)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x208b4
movq %rbx, %rdi
callq 0x759a
movq %r12, (%rbx)
jmp 0x2062b
movl %r15d, %eax
andl $0x7, %eax
leaq 0x15b07(%rip), %rcx     # 0x363d0
movq (%rcx,%rax,8), %rsi
cmpb $0x3f, (%rsi)
jne 0x208f4
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
movq %r12, 0x8(%rax)
movq $0x0, (%rax)
movq %r15, 0x18(%rax)
incl 0x10(%rax)
jmp 0x203f5
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
jmp 0x205af
callq 0x6070