// File: /workspace/github_c_makefile_star2_O2/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 0x15b14(%rip), %r13     # 0x329a0
movq %r13, %rsi
movl %r12d, %edx
movq %r15, %rcx
callq 0x10775
pushq $0x1
popq %r14
testq %rax, %rax
je 0x1d36a
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x1cec9
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 %rbx, -0x30(%rbp)
movq %rax, %rbx
subq %r13, %rbx
shrq $0x5, %rbx
cmpl $0x16, %ebx
ja 0x1d71a
xorl %r8d, %r8d
movl %ebx, %ecx
leaq 0x6650(%rip), %rdx      # 0x2353c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x10(%r15), %rsi
pushq $0x1
popq %r14
movq -0x30(%rbp), %rdi
movl %r14d, %edx
callq 0x6755
testq %rax, %rax
je 0x1d36a
cmpl $0x0, 0x4(%rax)
je 0x1d2cc
xorl %r14d, %r14d
cmpl $0x1, %ebx
je 0x1d48c
cmpl $0x14, %ebx
je 0x1d45c
cmpl $0x2, %ebx
jne 0x1d36a
movq 0x20(%rax), %rbx
jmp 0x1d490
leaq 0xc1f0(%rip), %rsi      # 0x2913a
xorl %r14d, %r14d
leaq -0x70(%rbp), %r15
pushq $0x54
popq %rcx
movq %r15, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x6480
pushq $-0x1
popq %rdx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x1cfca
cmpl $0x2, %r12d
jne 0x1d2dd
movq -0x30(%rbp), %rbx
movq 0x58(%rbx), %rax
movslq 0x8(%rax), %rsi
jmp 0x1d0f4
pushq $0x1
jmp 0x1d1ec
movq 0x10(%r15), %rsi
xorl %r14d, %r14d
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9378
xorl %esi, %esi
testq %rax, %rax
setne %sil
movq %rbx, %rdi
callq 0x8212
jmp 0x1cfcf
leaq 0xc3cc(%rip), %rsi      # 0x2938c
pushq $-0x1
popq %rdx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x7363
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 0x1cfee
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
jmp 0x1d36a
pushq $0x2
jmp 0x1d27e
leaq 0xc14b(%rip), %rsi      # 0x2914f
jmp 0x1d0c5
movq 0x10(%r15), %rsi
leaq -0x70(%rbp), %rdx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xad59
movl %eax, %esi
movq %rbx, %rdi
callq 0x8212
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1d046
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
cmpl $0x4, %r12d
jne 0x1d367
cmpb $0x20, -0x70(%rbp)
je 0x1d367
movq 0x18(%r15), %r14
leaq -0x70(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8306
jmp 0x1d367
cmpl $0x5, %r12d
je 0x1d395
cmpl $0x4, %r12d
movq -0x30(%rbp), %rbx
jne 0x1d421
movq (%r15), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1067e
jmp 0x1d36a
movq -0x30(%rbp), %r14
movq 0x188(%r14), %rbx
jmp 0x1d348
leaq 0xc07b(%rip), %rsi      # 0x29140
movq -0x30(%rbp), %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfce7
cmpl $0x2, %r12d
jne 0x1d30b
movq -0x30(%rbp), %rbx
movslq 0x110(%rbx), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x8212
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jl 0x1d2bc
jmp 0x1d2c4
movq 0x10(%r15), %rsi
pushq $0x1
popq %r14
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movl %r14d, %edx
callq 0x6755
testq %rax, %rax
je 0x1d36a
cmpl $0x0, 0x4(%rax)
jne 0x1d153
leaq 0x1d74(%rip), %rcx      # 0x1eebd
cmpq %rcx, 0x18(%rax)
je 0x1d6b7
movq 0x10(%r15), %rdx
leaq 0xbf9d(%rip), %rsi      # 0x290fb
movq %rbx, %rdi
jmp 0x1d337
cmpl $0x3, %r12d
je 0x1d3e9
movl $0x0, %r14d
cmpl $0x2, %r12d
movq -0x30(%rbp), %rdi
jne 0x1d36a
xorl %r15d, %r15d
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r14
leaq 0x142e6(%rip), %rbx     # 0x31480
pushq $-0x1
popq %r12
movq -0x30(%rbp), %r13
cmpq $0x8, %r15
je 0x1d388
movq %r13, %rdi
movq %r15, %rsi
callq 0x8212
movq %r13, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
movq (%rbx), %rsi
movq %r13, %rdi
movl %r12d, %edx
callq 0x7363
movq %r13, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
incq %r15
addq $0x8, %rbx
jmp 0x1d1a2
pushq $0x2
popq %r8
cmpl $0x3, %r12d
jne 0x1d1fa
movq 0x10(%r15), %rdx
jmp 0x1d1fc
xorl %edx, %edx
movq -0x30(%rbp), %rbx
testl %r8d, %r8d
je 0x1d21d
cmpl $0x1, %r8d
jne 0x1d219
movq 0x58(%rbx), %rax
cmpq 0x60(%rbx), %rax
je 0x1d37c
pushq $0x58
jmp 0x1d21f
pushq $0x60
popq %rax
movq (%rbx,%rax), %rsi
addq $0x10, %rsi
leaq 0x3a50(%rip), %rcx      # 0x20c7f
movq %rbx, %rdi
callq 0x20bbf
movq %rax, %r14
incl 0x10(%r14)
jmp 0x1d2ab
cmpl $0x3, %r12d
jne 0x1d340
movq 0x10(%r15), %rbx
incl 0x10(%rbx)
movq -0x30(%rbp), %r14
movq 0x10(%r14), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1d273
movq %r14, %rdi
callq 0x73bf
movq 0x10(%r15), %rbx
movq %rbx, 0x10(%r14)
jmp 0x1d348
pushq $0x1
popq %r8
cmpl $0x3, %r12d
jne 0x1d28c
movq 0x10(%r15), %rdx
jmp 0x1d28e
xorl %edx, %edx
movq -0x30(%rbp), %rbx
leaq 0x68(%rbx), %rsi
leaq 0x3a67(%rip), %rcx      # 0x20d04
movq %rbx, %rdi
callq 0x20bbf
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1d2c4
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
jmp 0x1d367
movq 0x10(%r15), %rdx
leaq 0xbe42(%rip), %rsi      # 0x29119
movq -0x30(%rbp), %rdi
jmp 0x1d337
movq 0x10(%r15), %r15
leaq -0x70(%rbp), %rdx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc8cb
testl %eax, %eax
je 0x1d4b8
leaq 0xb7e5(%rip), %rsi      # 0x28ae8
movq %rbx, %rdi
movq %r15, %rdx
jmp 0x1d337
movq 0x10(%r15), %r12
leaq -0x70(%rbp), %rdx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc8cb
testl %eax, %eax
je 0x1d4fb
leaq 0xb7b7(%rip), %rsi      # 0x28ae8
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x68a7
jmp 0x1d36a
movq -0x30(%rbp), %r14
movq 0x10(%r14), %rbx
incl 0x10(%rbx)
movq (%r14), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1d364
movq %r14, %rdi
callq 0x73bf
movq %rbx, (%r14)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x128(%rbx), %r14
jmp 0x1d23a
incl 0x10(%r14)
movq -0x30(%rbp), %rbx
jmp 0x1d2ab
movq 0x20(%r15), %rsi
leaq -0x70(%rbp), %rdx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xc979
testl %eax, %eax
jne 0x1d36a
movq 0x10(%r15), %rdi
callq 0x7340
movq %rax, %r14
movq 0x10(%r15), %rdi
callq 0xa61a
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x7363
movq %rax, %r14
movq 0x18(%r15), %rdx
movl -0x70(%rbp), %ecx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb3cf
jmp 0x1d23a
movq 0x10(%r15), %rsi
leaq -0x70(%rbp), %rdx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xc8cb
testl %eax, %eax
jne 0x1d36a
movq -0x70(%rbp), %rsi
testl $0xfffffff8, %esi       # imm = 0xFFFFFFF8
je 0x1d6ee
leaq 0xa042(%rip), %rax      # 0x2745e
jmp 0x1d6fe
movq 0x10(%r15), %rsi
leaq -0x70(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xb377
movq %rax, %r12
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x74ad
movslq (%r15), %rsi
jmp 0x1d69c
movq 0x28(%rax), %rsi
testq %rsi, %rsi
movq -0x30(%rbp), %rbx
je 0x1d36a
leaq 0x380b(%rip), %rcx      # 0x20c7f
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1001, %r8d           # imm = 0x1001
callq 0x20bbf
jmp 0x1cfcf
movq 0x18(%rax), %rbx
incl 0x10(%rbx)
movq -0x30(%rbp), %r15
movq (%r15), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1d4b0
movq %r15, %rdi
callq 0x73bf
movq %rbx, (%r15)
jmp 0x1d36a
movq -0x70(%rbp), %rax
testq %rax, %rax
je 0x1d6c3
jns 0x1d4d8
movq 0x58(%rbx), %rcx
movslq 0x8(%rcx), %rcx
addq %rcx, %rax
jle 0x1d2fc
leaq 0x58(%rbx), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x1d2fc
movslq 0x8(%rcx), %rdx
cmpq %rdx, %rax
je 0x1d6d0
addq $0x48, %rcx
jmp 0x1d4dc
movl -0x70(%rbp), %esi
movq %rbx, %rdi
callq 0x190a7
testq %rax, %rax
je 0x1d32a
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r14
leaq 0x9691(%rip), %rsi      # 0x26bb9
pushq $-0x1
popq %r12
movq %rbx, %rdi
movl %r12d, %edx
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
leaq 0xa621(%rip), %rsi      # 0x27b6d
movq %rbx, %rdi
movl %r12d, %edx
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
movq 0x30(%r15), %rsi
testq %rsi, %rsi
je 0x1d5e8
movq %rbx, %rdi
callq 0xad8c
movq %rax, %r12
leaq 0x94fb(%rip), %rsi      # 0x26a7b
pushq $-0x1
popq %r13
movq %rbx, %rdi
movl %r13d, %edx
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
movslq 0x20(%r12), %rsi
movq %rbx, %rdi
callq 0x8212
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
leaq 0xa360(%rip), %rsi      # 0x2791f
movq %rbx, %rdi
movl %r13d, %edx
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
movq 0x8(%r12), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74ad
movq 0x20(%r15), %rsi
movl 0x28(%r15), %edx
movq %rbx, %rdi
callq 0x745b
movq %rax, %r12
leaq 0xac30(%rip), %rsi      # 0x28232
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x74ad
movq %rbx, %rdi
movq %r15, %rsi
callq 0x191e9
testq %rax, %rax
je 0x1d66a
movq %rax, %r12
leaq 0xbb2a(%rip), %rsi      # 0x2916d
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x74ad
leaq 0xb471(%rip), %rsi      # 0x28ae2
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
movq 0x58(%rbx), %rax
movslq 0x8(%rax), %rsi
movq (%r15), %rax
movslq 0x8(%rax), %rax
subq %rax, %rsi
movq %rbx, %rdi
callq 0x8212
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
jmp 0x1d23a
movq %rbx, %r14
movq 0x28(%rax), %rbx
jmp 0x1d348
movq 0x58(%rbx), %rcx
testq %rcx, %rcx
je 0x1d2fc
cmpq 0x60(%rbx), %rcx
je 0x1d2fc
movq 0x50(%rcx), %rsi
movl 0x58(%rcx), %edx
movq %rbx, %rdi
callq 0x745b
jmp 0x1d2a5
movl %esi, %eax
andl $0x7, %eax
leaq 0x13d86(%rip), %rcx     # 0x31480
movq (%rcx,%rax,8), %rax
cmpb $0x3f, (%rax)
je 0x1d0f4
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7363
jmp 0x1d2a5
callq 0x6070