// File: /workspace/github_c_makefile_star2_O3/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 0x16ff3(%rip), %r13     # 0x369a0
movq %r13, %rsi
movl %r12d, %edx
movq %r15, %rcx
callq 0x11a8f
movl $0x1, %r14d
testq %rax, %rax
je 0x201b7
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x1f9ec
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 0x20235
xorl %r8d, %r8d
movl %ebx, %ecx
leaq 0x7b51(%rip), %rdx      # 0x27560
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x10(%r15), %rsi
movl $0x1, %r14d
movq -0x30(%rbp), %rdi
movl $0x1, %edx
callq 0x67d1
testq %rax, %rax
je 0x201b7
cmpl $0x0, 0x4(%rax)
je 0x1fef2
xorl %r14d, %r14d
cmpl $0x1, %ebx
je 0x200df
cmpl $0x14, %ebx
je 0x200af
cmpl $0x2, %ebx
jne 0x201b7
movq 0x20(%rax), %rbx
jmp 0x200e3
leaq 0xd679(%rip), %rsi      # 0x2d0ea
xorl %r14d, %r14d
leaq -0x70(%rbp), %r15
movq %r15, %rdi
xorl %edx, %edx
movl $0x54, %ecx
xorl %eax, %eax
callq 0x6480
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x1fb31
cmpl $0x2, %r12d
jne 0x1ff0d
movq -0x30(%rbp), %r15
movq 0x58(%r15), %rax
movslq 0x8(%rax), %rbx
jmp 0x1fcbd
movl $0x1, %r8d
jmp 0x1fdfd
movq 0x10(%r15), %rsi
xorl %r14d, %r14d
movq -0x30(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x98e7
xorl %ebx, %ebx
testq %rax, %rax
setne %bl
movq %r12, %rdi
callq 0xae38
movq %rax, %r15
leaq 0x15803(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
movq %rbx, 0x18(%r15)
incl 0x10(%r15)
movq (%r12), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1fb1a
movq %r12, %rdi
callq 0x758c
movq %r15, (%r12)
jmp 0x201b7
leaq 0xd812(%rip), %rsi      # 0x2d33c
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
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 0x1fb5a
movq %rbx, %rdi
callq 0x758c
movq %r15, (%rbx)
jmp 0x201b7
movl $0x2, %r8d
jmp 0x1fea6
leaq 0xd58b(%rip), %rsi      # 0x2d0ff
jmp 0x1fc8e
movq 0x10(%r15), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xb679
movl 0x24(%rax), %ecx
cmpl $0x20, %ecx
sete %al
movl %ecx, -0x34(%rbp)
cmpl $0x7d, %ecx
sete %cl
orb %al, %cl
movzbl %cl, %r13d
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x1573d(%rip), %rax     # 0x352f0
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 0x1fbdf
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r14d, %r14d
cmpl $0x4, %r12d
jne 0x201b7
movl -0x34(%rbp), %r13d
cmpb $0x20, %r13b
je 0x201b7
movq 0x18(%r15), %r15
movq %rbx, %rdi
callq 0xae38
movq %rax, %r12
xorl %r14d, %r14d
movl $0x2, %esi
xorl %edi, %edi
callq *0x1766c(%rip)          # 0x37288
movb %r13b, (%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 0x876e
jmp 0x201b7
cmpl $0x5, %r12d
je 0x1ff78
cmpl $0x4, %r12d
movq -0x30(%rbp), %r13
jne 0x2007a
movq (%r15), %rdx
movq %r13, %rdi
movq %rax, %rsi
callq 0x1198a
jmp 0x201b7
movq -0x30(%rbp), %r14
movq 0x188(%r14), %rbx
jmp 0x1ff54
leaq 0xd462(%rip), %rsi      # 0x2d0f0
movq -0x30(%rbp), %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10f19
cmpl $0x2, %r12d
jne 0x1ff23
movq -0x30(%rbp), %r15
movslq 0x110(%r15), %rbx
incq %rbx
movq %r15, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x15621(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %rbx, 0x18(%r14)
incl 0x10(%r14)
movq (%r15), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jge 0x1fcfb
movq %r15, %rdi
callq 0x758c
movq %r14, (%r15)
jmp 0x201b4
movq 0x10(%r15), %rsi
movl $0x1, %r14d
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movl $0x1, %edx
callq 0x67d1
testq %rax, %rax
je 0x201b7
cmpl $0x0, 0x4(%rax)
jne 0x1fd3e
leaq 0x1f71(%rip), %rcx      # 0x21ca5
cmpq %rcx, 0x18(%rax)
je 0x20114
movq 0x10(%r15), %rdx
leaq 0xd362(%rip), %rsi      # 0x2d0ab
movq %rbx, %rdi
jmp 0x1ff01
xorl %r14d, %r14d
cmpl $0x3, %r12d
je 0x2002e
cmpl $0x2, %r12d
movq -0x30(%rbp), %r13
jne 0x201b7
movq %r13, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x155ea(%rip), %rax     # 0x35368
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
leaq 0x15648(%rip), %r15     # 0x353e0
xorl %r12d, %r12d
leaq 0x1554e(%rip), %rbx     # 0x352f0
movq %r13, %rdi
callq 0xae38
movq %rbx, 0x8(%rax)
movq $0x0, (%rax)
movq %r12, 0x18(%rax)
movq %r13, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7683
movq (%r15), %rsi
movq %r13, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %r13, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7683
incq %r12
addq $0x8, %r15
cmpq $0x8, %r12
jne 0x1fda2
jmp 0x20192
movl $0x2, %r8d
cmpl $0x3, %r12d
jne 0x1fe09
movq 0x10(%r15), %rdx
jmp 0x1fe0b
xorl %edx, %edx
movq -0x30(%rbp), %rbx
testl %r8d, %r8d
je 0x1fe2d
cmpl $0x1, %r8d
jne 0x1fe44
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
jne 0x1fe48
movq 0x128(%rbx), %r14
jmp 0x1fe5e
movq 0x60(%rbx), %rsi
addq $0x10, %rsi
leaq 0x4da5(%rip), %rcx      # 0x24be1
movq %rbx, %rdi
xorl %r8d, %r8d
jmp 0x1fe56
movq 0x58(%rbx), %rsi
addq $0x10, %rsi
leaq 0x4d8e(%rip), %rcx      # 0x24be1
movq %rbx, %rdi
callq 0x24aea
movq %rax, %r14
incl 0x10(%r14)
jmp 0x1fed1
cmpl $0x3, %r12d
jne 0x1ff4c
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 0x1fe97
movq %r14, %rdi
callq 0x758c
movq 0x10(%r15), %rbx
movq %rbx, 0x10(%r14)
jmp 0x1ff54
movl $0x1, %r8d
cmpl $0x3, %r12d
jne 0x1feb2
movq 0x10(%r15), %rdx
jmp 0x1feb4
xorl %edx, %edx
movq -0x30(%rbp), %rbx
leaq 0x68(%rbx), %rsi
leaq 0x4da3(%rip), %rcx      # 0x24c66
movq %rbx, %rdi
callq 0x24aea
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 0x1feea
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
jmp 0x201b4
movq 0x10(%r15), %rdx
leaq 0xd1cc(%rip), %rsi      # 0x2d0c9
movq -0x30(%rbp), %rdi
xorl %eax, %eax
callq 0x6923
jmp 0x201b7
movq 0x10(%r15), %rsi
leaq -0x70(%rbp), %rdx
movq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x247c2
jmp 0x1ff37
movq 0x10(%r15), %rsi
leaq -0x70(%rbp), %rdx
movq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x2486d
testl %eax, %eax
jne 0x201b7
movq -0x70(%rbp), %r14
incl 0x10(%r14)
jmp 0x2021b
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 0x1ff70
movq %r14, %rdi
callq 0x758c
movq %rbx, (%r14)
jmp 0x201b4
movq 0x20(%r15), %r12
leaq 0x1536d(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r12)
movq -0x30(%rbp), %rbx
je 0x1ffac
movl $0x1, %r14d
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x201b7
movq 0x18(%r12), %r13
movq 0x10(%r15), %r14
movq (%r14), %r12
testq %r12, %r12
jne 0x1ffde
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r12
movq 0x10(%r15), %r14
cmpq $0x0, (%r14)
jne 0x1ffde
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movl 0x14(%r14), %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7508
movq %rax, %r14
movq 0x18(%r15), %rbx
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x2000f
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x2000f
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq *%rax
incl 0x10(%rbx)
movq %rbx, 0x18(%r14)
movl %r13d, 0x20(%r14)
leaq 0x151c7(%rip), %rax     # 0x351e8
movq %rax, 0x8(%r14)
movq -0x30(%rbp), %r13
jmp 0x20192
movq 0x10(%r15), %r15
leaq 0x152b7(%rip), %r12     # 0x352f0
cmpq %r12, 0x8(%r15)
movq -0x30(%rbp), %rdi
je 0x2005e
movl $0x1, %r14d
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x201b7
movq 0x18(%r15), %rbx
testl $0xfffffff8, %ebx       # imm = 0xFFFFFFF8
je 0x201c9
leaq 0xb399(%rip), %rsi      # 0x2b40e
jmp 0x201d9
movq 0x10(%r15), %rax
movq 0x8(%rax), %rcx
leaq 0x1515f(%rip), %rdx     # 0x351e8
cmpq %rdx, %rcx
je 0x2010b
leaq 0x1517b(%rip), %rdx     # 0x35210
cmpq %rdx, %rcx
je 0x20120
leaq 0x128(%r13), %rax
movl $0x1, %ebx
jmp 0x20132
movq 0x28(%rax), %rsi
testq %rsi, %rsi
movq -0x30(%rbp), %rbx
je 0x201b7
leaq 0x4b1a(%rip), %rcx      # 0x24be1
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1001, %r8d           # imm = 0x1001
callq 0x24aea
jmp 0x1fb3b
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 0x20103
movq %r15, %rdi
callq 0x758c
movq %rbx, (%r15)
jmp 0x201b7
movl 0x20(%rax), %ebx
addq $0x18, %rax
jmp 0x20132
movq %rbx, %r14
movq 0x28(%rax), %rbx
jmp 0x1ff54
movq %r13, %rdi
movq %rax, %rsi
callq 0xb679
movl 0x1c(%rax), %ebx
addq $0x8, %rax
movq (%rax), %r15
movq %r13, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x15221(%rip), %rax     # 0x35368
movq %rax, 0x8(%r14)
xorl %r12d, %r12d
movq %r12, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7683
movslq %ebx, %rbx
movq %r13, %rdi
callq 0xae38
leaq 0x15177(%rip), %rcx     # 0x352f0
movq %rcx, 0x8(%rax)
movq %r12, (%rax)
movq %rbx, 0x18(%rax)
movq %r13, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7683
incl 0x10(%r14)
movq (%r13), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x201b0
movq %r13, %rdi
callq 0x758c
movq %r14, (%r13)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %eax
andl $0x7, %eax
leaq 0x1520b(%rip), %rcx     # 0x353e0
movq (%rcx,%rax,8), %rsi
cmpb $0x3f, (%rsi)
jne 0x20204
movq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0xae38
movq %rax, %r14
movq %r12, 0x8(%rax)
movq $0x0, (%rax)
movq %rbx, 0x18(%rax)
incl 0x10(%rax)
jmp 0x1fce2
movq -0x30(%rbp), %r15
movq %r15, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r14
incl 0x10(%rax)
movq (%r15), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jle 0x1fcf3
jmp 0x1fcfb
callq 0x6070