// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxCmdIL.c
// Function: Hax_InfoCmd
int
Hax_InfoCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    Interp *iPtr = (Interp *) interp;
    int length;
    char c;
    Arg *argPtr;
    Proc *procPtr;
    Var *varPtr;
    Command *cmdPtr;
    Hax_HashEntry *hPtr;
    Hax_HashSearch search;

    if (argc < 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" option ?arg arg ...?\"", (char *) NULL);
	return HAX_ERROR;
    }
    c = argv[1][0];
    length = strlen(argv[1]);
    if ((c == 'a') && (strncmp(argv[1], "args", length)) == 0) {
	if (argc != 3) {
	    Hax_AppendResult(interp, "wrong # args: should be \"",
		    argv[0], " args procname\"", (char *) NULL);
	    return HAX_ERROR;
	}
	procPtr = HaxFindProc(iPtr, argv[2]);
	if (procPtr == NULL) {
	    infoNoSuchProc:
	    Hax_AppendResult(interp, "\"", argv[2],
		    "\" isn't a procedure", (char *) NULL);
	    return HAX_ERROR;
	}
	for (argPtr = procPtr->argPtr; argPtr != NULL;
		argPtr = argPtr->nextPtr) {
	    Hax_AppendElement(interp, argPtr->name, 0);
	}
	return HAX_OK;
    } else if ((c == 'b') && (strncmp(argv[1], "body", length)) == 0) {
	if (argc != 3) {
	    Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		    " body procname\"", (char *) NULL);
	    return HAX_ERROR;
	}
	procPtr = HaxFindProc(iPtr, argv[2]);
	if (procPtr == NULL) {
	    goto infoNoSuchProc;
	}
	iPtr->result = procPtr->command;
	return HAX_OK;
    } else if ((c == 'c') && (strncmp(argv[1], "cmdcount", length) == 0)
	    && (length >= 2)) {
	if (argc != 2) {
	    Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		    " cmdcount\"", (char *) NULL);
	    return HAX_ERROR;
	}
	sprintf(iPtr->result, "%d", iPtr->cmdCount);
	return HAX_OK;
    } else if ((c == 'c') && (strncmp(argv[1], "commands", length) == 0)
	    && (length >= 4)) {
	if (argc > 3) {
	    Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		    " commands [pattern]\"", (char *) NULL);
	    return HAX_ERROR;
	}
	for (hPtr = Hax_FirstHashEntry(&iPtr->commandTable, &search);
		hPtr != NULL; hPtr = Hax_NextHashEntry(&search)) {
	    char *name = Hax_GetHashKey(&iPtr->commandTable, hPtr);
	    if ((argc == 3) && !Hax_StringMatch(name, argv[2])) {
		continue;
	    }
	    Hax_AppendElement(interp, name, 0);
	}
	return HAX_OK;
    } else if ((c == 'c') && (strncmp(argv[1], "complete", length) == 0)
	    && (length >= 4)) {
	if (argc != 3) {
	    Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		    " complete command\"", (char *) NULL);
	    return HAX_ERROR;
	}
	if (Hax_CommandComplete(argv[2])) {
	    interp->result = (char *) "1";
	} else {
	    interp->result = (char *) "0";
	}
	return HAX_OK;
    } else if ((c == 'd') && (strncmp(argv[1], "default", length)) == 0) {
	if (argc != 5) {
	    Hax_AppendResult(interp, "wrong # args: should be \"",
		    argv[0], " default procname arg varname\"",
		    (char *) NULL);
	    return HAX_ERROR;
	}
	procPtr = HaxFindProc(iPtr, argv[2]);
	if (procPtr == NULL) {
	    goto infoNoSuchProc;
	}
	for (argPtr = procPtr->argPtr; ; argPtr = argPtr->nextPtr) {
	    if (argPtr == NULL) {
		Hax_AppendResult(interp, "procedure \"", argv[2],
			"\" doesn't have an argument \"", argv[3],
			"\"", (char *) NULL);
		return HAX_ERROR;
	    }
	    if (strcmp(argv[3], argPtr->name) == 0) {
		if (argPtr->defValue != NULL) {
		    if (Hax_SetVar((Hax_Interp *) iPtr, argv[4],
			    argPtr->defValue, 0) == NULL) {
			defStoreError:
			Hax_AppendResult(interp,
				"couldn't store default value in variable \"",
				argv[4], "\"", (char *) NULL);
			return HAX_ERROR;
		    }
		    iPtr->result = (char *) "1";
		} else {
		    if (Hax_SetVar((Hax_Interp *) iPtr, argv[4], (char *) "", 0)
			    == NULL) {
			goto defStoreError;
		    }
		    iPtr->result = (char *) "0";
		}
		return HAX_OK;
	    }
	}
    } else if ((c == 'e') && (strncmp(argv[1], "exists", length) == 0)) {
	char *p;
	if (argc != 3) {
	    Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		    " exists varName\"", (char *) NULL);
	    return HAX_ERROR;
	}
	p = Hax_GetVar((Hax_Interp *) iPtr, argv[2], 0);

	/*
	 * The code below handles the special case where the name is for
	 * an array:  Hax_GetVar will reject this since you can't read
	 * an array variable without an index.
	 */

	if (p == NULL) {
	    Hax_HashEntry *hPtr;
	    Var *varPtr;

	    if (strchr(argv[2], '(') != NULL) {
		noVar:
		iPtr->result = (char *) "0";
		return HAX_OK;
	    }
	    if (iPtr->varFramePtr == NULL) {
		hPtr = Hax_FindHashEntry(&iPtr->globalTable, argv[2]);
	    } else {
		hPtr = Hax_FindHashEntry(&iPtr->varFramePtr->varTable, argv[2]);
	    }
	    if (hPtr == NULL) {
		goto noVar;
	    }
	    varPtr = (Var *) Hax_GetHashValue(hPtr);
	    if (varPtr->flags & VAR_UPVAR) {
		varPtr = (Var *) Hax_GetHashValue(varPtr->value.upvarPtr);
	    }
	    if (!(varPtr->flags & VAR_ARRAY)) {
		goto noVar;
	    }
	}
	iPtr->result = (char *) "1";
	return HAX_OK;
    } else if ((c == 'g') && (strncmp(argv[1], "globals", length) == 0)) {
	char *name;

	if (argc > 3) {
	    Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		    " globals [pattern]\"", (char *) NULL);
	    return HAX_ERROR;
	}
	for (hPtr = Hax_FirstHashEntry(&iPtr->globalTable, &search);
		hPtr != NULL; hPtr = Hax_NextHashEntry(&search)) {
	    varPtr = (Var *) Hax_GetHashValue(hPtr);
	    if (varPtr->flags & VAR_UNDEFINED) {
		continue;
	    }
	    name = Hax_GetHashKey(&iPtr->globalTable, hPtr);
	    if ((argc == 3) && !Hax_StringMatch(name, argv[2])) {
		continue;
	    }
	    Hax_AppendElement(interp, name, 0);
	}
	return HAX_OK;
    } else if ((c == 'l') && (strncmp(argv[1], "level", length) == 0)
	    && (length >= 2)) {
	if (argc == 2) {
	    if (iPtr->varFramePtr == NULL) {
		iPtr->result = (char *) "0";
	    } else {
		sprintf(iPtr->result, "%d", iPtr->varFramePtr->level);
	    }
	    return HAX_OK;
	} else if (argc == 3) {
	    int level;
	    CallFrame *framePtr;

	    if (Hax_GetInt(interp, argv[2], &level) != HAX_OK) {
		return HAX_ERROR;
	    }
	    if (level <= 0) {
		if (iPtr->varFramePtr == NULL) {
		    levelError:
		    Hax_AppendResult(interp, "bad level \"", argv[2],
			    "\"", (char *) NULL);
		    return HAX_ERROR;
		}
		level += iPtr->varFramePtr->level;
	    }
	    for (framePtr = iPtr->varFramePtr; framePtr != NULL;
		    framePtr = framePtr->callerVarPtr) {
		if (framePtr->level == level) {
		    break;
		}
	    }
	    if (framePtr == NULL) {
		goto levelError;
	    }
	    iPtr->result = Hax_Merge(interp, framePtr->argc, framePtr->argv);
	    iPtr->freeProc = (Hax_FreeProc *) free;
	    return HAX_OK;
	}
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" level [number]\"", (char *) NULL);
	return HAX_ERROR;
    } else if ((c == 'l') && (strncmp(argv[1], "library", length) == 0)
	    && (length >= 2)) {
	if (argc != 2) {
	    Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		    " library\"", (char *) NULL);
	    return HAX_ERROR;
	}

	if (iPtr->libraryPath == NULL) {
	    interp->result =
		(char *) "there is no Hax library at this installation";
	    return HAX_ERROR;
	}
	interp->result = iPtr->libraryPath;
	return HAX_OK;
    } else if ((c == 'l') && (strncmp(argv[1], "locals", length) == 0)
	    && (length >= 2)) {
	char *name;

	if (argc > 3) {
	    Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		    " locals [pattern]\"", (char *) NULL);
	    return HAX_ERROR;
	}
	if (iPtr->varFramePtr == NULL) {
	    return HAX_OK;
	}
	for (hPtr = Hax_FirstHashEntry(&iPtr->varFramePtr->varTable, &search);
		hPtr != NULL; hPtr = Hax_NextHashEntry(&search)) {
	    varPtr = (Var *) Hax_GetHashValue(hPtr);
	    if (varPtr->flags & (VAR_UNDEFINED|VAR_UPVAR)) {
		continue;
	    }
	    name = Hax_GetHashKey(&iPtr->varFramePtr->varTable, hPtr);
	    if ((argc == 3) && !Hax_StringMatch(name, argv[2])) {
		continue;
	    }
	    Hax_AppendElement(interp, name, 0);
	}
	return HAX_OK;
    } else if ((c == 'p') && (strncmp(argv[1], "patchlevel", length) == 0)) {
	if (argc != 2) {
	    Hax_AppendResult(interp, "wrong # args: should be \"",
		    argv[0], " patchlevel\"", (char *) NULL);
	    return HAX_ERROR;
	}

	strcpy(iPtr->result, HAX_PATCHLEVEL);
	return HAX_OK;
    } else if ((c == 'p') && (strncmp(argv[1], "procs", length)) == 0) {
	if (argc > 3) {
	    Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		    " procs [pattern]\"", (char *) NULL);
	    return HAX_ERROR;
	}
	for (hPtr = Hax_FirstHashEntry(&iPtr->commandTable, &search);
		hPtr != NULL; hPtr = Hax_NextHashEntry(&search)) {
	    char *name = Hax_GetHashKey(&iPtr->commandTable, hPtr);

	    cmdPtr = (Command *) Hax_GetHashValue(hPtr);
	    if (!HaxIsProc(cmdPtr)) {
		continue;
	    }
	    if ((argc == 3) && !Hax_StringMatch(name, argv[2])) {
		continue;
	    }
	    Hax_AppendElement(interp, name, 0);
	}
	return HAX_OK;
    } else if ((c == 's') && (strncmp(argv[1], "script", length) == 0)) {
	if (argc != 2) {
	    Hax_AppendResult(interp, "wrong # args: should be \"",
		    argv[0], " script\"", (char *) NULL);
	    return HAX_ERROR;
	}
	if (iPtr->scriptFile != NULL) {
	    interp->result = iPtr->scriptFile;
	}
	return HAX_OK;
    } else if ((c == 't') && (strncmp(argv[1], "tclversion", length) == 0)) {
	if (argc != 2) {
	    Hax_AppendResult(interp, "wrong # args: should be \"",
		    argv[0], " tclversion\"", (char *) NULL);
	    return HAX_ERROR;
	}

	strcpy(iPtr->result, HAX_VERSION);
	return HAX_OK;
    } else if ((c == 'v') && (strncmp(argv[1], "vars", length)) == 0) {
	Hax_HashTable *tablePtr;
	char *name;

	if (argc > 3) {
	    Hax_AppendResult(interp, "wrong # args: should be \"",
		    argv[0], " vars [pattern]\"", (char *) NULL);
	    return HAX_ERROR;
	}
	if (iPtr->varFramePtr == NULL) {
	    tablePtr = &iPtr->globalTable;
	} else {
	    tablePtr = &iPtr->varFramePtr->varTable;
	}
	for (hPtr = Hax_FirstHashEntry(tablePtr, &search);
		hPtr != NULL; hPtr = Hax_NextHashEntry(&search)) {
	    varPtr = (Var *) Hax_GetHashValue(hPtr);
	    if (varPtr->flags & VAR_UNDEFINED) {
		continue;
	    }
	    name = Hax_GetHashKey(tablePtr, hPtr);
	    if ((argc == 3) && !Hax_StringMatch(name, argv[2])) {
		continue;
	    }
	    Hax_AppendElement(interp, name, 0);
	}
	return HAX_OK;
    } else {
	Hax_AppendResult(interp, "bad option \"", argv[1],
		"\": should be args, body, cmdcount, commands, ",
		"complete, default, ",
		"exists, globals, level, library, locals, patchlevel, procs, ",
		"script, tclversion, or vars",
		(char *) NULL);
	return HAX_ERROR;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x1, %edx
jg 0x8980
movq (%r14), %rdx
leaq 0xcf0d(%rip), %rsi      # 0x15874
leaq 0xd44f(%rip), %rcx      # 0x15dbd
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
jmp 0x9157
movl %edx, %ebp
movq 0x8(%r14), %r15
movzbl (%r15), %r13d
movq %r15, %rdi
callq 0x41d0
movq %rax, %r12
leal -0x61(%r13), %eax
cmpl $0x15, %eax
ja 0x911f
leaq 0xd13f(%rip), %rcx      # 0x15ae8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq %r12d, %rdx
leaq 0xd418(%rip), %rsi      # 0x15dd4
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x8adb
leal -0x62(%r13), %eax
cmpl $0x14, %eax
ja 0x911f
leaq 0xd160(%rip), %rcx      # 0x15b40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq %r12d, %rdx
leaq 0xcee4(%rip), %rsi      # 0x158d7
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x8ab1
leal -0x63(%r13), %eax
cmpl $0x13, %eax
ja 0x911f
leaq 0xd17d(%rip), %rcx      # 0x15b94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, 0x8(%rsp)
movslq %r12d, %rbx
leaq 0xd3de(%rip), %rsi      # 0x15e0d
movq %r15, %rdi
movq %rbx, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
cmpl $0x2, %r12d
setge %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8a69
cmpl $0x2, %ebp
jne 0x8b2a
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movl 0x190(%rax), %edx
jmp 0x8e56
leaq 0xd3b1(%rip), %rsi      # 0x15e21
movq %r15, %rdi
movq %rbx, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
cmpl $0x4, %r12d
setge %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8b40
cmpl $0x4, %ebp
jl 0x8bcb
movq (%r14), %rdx
leaq 0xcdcf(%rip), %rsi      # 0x15874
leaq 0xd37e(%rip), %rcx      # 0x15e2a
jmp 0x92c7
cmpl $0x3, %ebp
jne 0x8b9f
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x4490
testq %rax, %rax
movq %rbx, %rdi
je 0x8d07
movq 0x8(%rax), %rax
jmp 0x9349
cmpl $0x3, %ebp
jne 0x8bb5
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x4490
testq %rax, %rax
movq %rbx, %rdi
je 0x8d07
movq 0x10(%rax), %rbx
testq %rbx, %rbx
je 0x934c
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x4050
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x8b0f
jmp 0x915d
movq (%r14), %rdx
leaq 0xcd40(%rip), %rsi      # 0x15874
leaq 0xd2db(%rip), %rcx      # 0x15e16
jmp 0x92c7
cmpl $0x4, %r12d
setge 0x7(%rsp)
leaq 0xd2ef(%rip), %rsi      # 0x15e3f
movq %r15, %rdi
movq %rbx, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
andb 0x7(%rsp), %al
cmpb $0x1, %al
jne 0x8c3e
cmpl $0x3, %ebp
movq 0x8(%rsp), %rbx
jne 0x9408
movq 0x10(%r14), %rdi
callq 0x44f0
testl %eax, %eax
leaq 0xd401(%rip), %rax      # 0x15f8d
leaq 0xd79a(%rip), %rcx      # 0x1632d
cmoveq %rax, %rcx
movq %rcx, (%rbx)
jmp 0x934c
movq (%r14), %rdx
leaq 0xcccb(%rip), %rsi      # 0x15874
leaq 0xd24d(%rip), %rcx      # 0x15dfd
jmp 0x896e
movq (%r14), %rdx
leaq 0xccb5(%rip), %rsi      # 0x15874
leaq 0xd213(%rip), %rcx      # 0x15dd9
jmp 0x896e
movq 0x8(%rsp), %rax
leaq 0x18(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x43d0
testq %rax, %rax
je 0x934c
movq %rax, %r12
leaq 0x10(%rsp), %rbx
xorl %r15d, %r15d
addq $0x20, %r12
movq 0x8(%rsp), %rax
cmpl $0x1, 0x54(%rax)
jne 0x8c05
movq (%r12), %r12
cmpl $0x3, %ebp
jne 0x8c1a
movq 0x10(%r14), %rsi
movq %r12, %rdi
callq 0x4460
testl %eax, %eax
je 0x8c29
movq 0x8(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4050
movq %rbx, %rdi
callq 0x4380
movq %rax, %r12
testq %rax, %rax
jne 0x8bf2
jmp 0x915d
leal -0x64(%r13), %eax
cmpl $0x12, %eax
movq 0x8(%rsp), %rbx
ja 0x911f
leaq 0xcf8d(%rip), %rcx      # 0x15be4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq %r12d, %rdx
leaq 0xcc72(%rip), %rsi      # 0x158dc
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x8c93
leal -0x6c(%r13), %eax
cmpl $0xa, %eax
ja 0x8d1e
leaq 0xcfa6(%rip), %rcx      # 0x15c30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x5, %ebp
jne 0x8da5
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x4490
movq %rbx, %rdi
testq %rax, %rax
je 0x8d07
movq %rax, %rbx
movq %rdi, %r15
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x942d
movq 0x18(%r14), %rdi
leaq 0x10(%rbx), %rsi
callq 0x4310
testl %eax, %eax
jne 0x8cba
movq 0x8(%rbx), %rdx
movq 0x20(%r14), %rsi
testq %rdx, %rdx
je 0x94cf
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x4450
testq %rax, %rax
je 0x94f4
leaq 0xd62b(%rip), %rax      # 0x1632d
jmp 0x94ec
movq 0x10(%r14), %rdx
leaq 0xc59d(%rip), %rsi      # 0x152af
leaq 0xd0d0(%rip), %rcx      # 0x15de9
jmp 0x8971
cmpl $0x67, %r13d
je 0x8dc5
cmpl $0x65, %r13d
jne 0x911f
movslq %r12d, %rdx
leaq 0xe924(%rip), %rsi      # 0x17660
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x8d61
leal -0x6c(%r13), %eax
cmpl $0xa, %eax
ja 0x8dbb
leaq 0xcf04(%rip), %rcx      # 0x15c5c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x3, %ebp
jne 0x8d8f
movq 0x10(%r14), %rsi
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4550
testq %rax, %rax
movq %rbx, %r12
je 0x93e2
leaq 0xd5a3(%rip), %rax      # 0x1632d
jmp 0x93ff
movq (%r14), %rdx
leaq 0xcadb(%rip), %rsi      # 0x15874
leaq 0xd12e(%rip), %rcx      # 0x15ece
jmp 0x896e
movq (%r14), %rdx
leaq 0xcac5(%rip), %rsi      # 0x15874
leaq 0xd0a5(%rip), %rcx      # 0x15e5b
jmp 0x896e
cmpl $0x67, %r13d
jne 0x911f
movslq %r12d, %rdx
leaq 0xd110(%rip), %rsi      # 0x15edf
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x8eba
leal -0x6c(%r13), %eax
cmpl $0xa, %eax
ja 0x911f
leaq 0xce95(%rip), %rcx      # 0x15c88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, 0x8(%rsp)
movslq %r12d, %rbx
leaq 0xe4ab(%rip), %rsi      # 0x172b6
movq %r15, %rdi
movq %rbx, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
cmpl $0x2, %r12d
setge %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8e6c
cmpl $0x3, %ebp
je 0x8f29
cmpl $0x2, %ebp
movq 0x8(%rsp), %rdi
jne 0x8fae
movq 0xc8(%rdi), %rax
testq %rax, %rax
je 0x9342
movq (%rdi), %rdi
movl 0x50(%rax), %edx
leaq 0xc4b6(%rip), %rsi      # 0x15313
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x45d0
jmp 0x915d
cmpl $0x2, %r12d
setge 0x7(%rsp)
leaq 0xd09c(%rip), %rsi      # 0x15f18
movq %r15, %rdi
movq %rbx, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
andb 0x7(%rsp), %al
cmpb $0x1, %al
jne 0x8ed9
cmpl $0x2, %ebp
jne 0x9038
movq 0x8(%rsp), %rcx
movq 0x288(%rcx), %rax
testq %rax, %rax
je 0x941e
movq %rax, (%rcx)
jmp 0x934c
cmpl $0x4, %ebp
jl 0x8fc4
movq (%r14), %rdx
leaq 0xc9a7(%rip), %rsi      # 0x15874
leaq 0xd013(%rip), %rcx      # 0x15ee7
jmp 0x896e
cmpl $0x2, %r12d
setge 0x7(%rsp)
leaq 0xd06e(%rip), %rsi      # 0x15f57
movq %r15, %rdi
movq %rbx, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
andb 0x7(%rsp), %al
cmpb $0x1, %al
jne 0x904e
cmpl $0x4, %ebp
movq 0x8(%rsp), %rdi
jl 0x9354
movq (%r14), %rdx
leaq 0xc957(%rip), %rsi      # 0x15874
leaq 0xd03a(%rip), %rcx      # 0x15f5e
jmp 0x8971
movq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x41c0
movl $0x1, %r15d
testl %eax, %eax
jne 0x915d
movl 0x10(%rsp), %eax
testl %eax, %eax
jg 0x8f68
movq 0xc8(%rbx), %rcx
testq %rcx, %rcx
je 0x8f8a
addl 0x50(%rcx), %eax
movl %eax, 0x10(%rsp)
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0x8f8a
movl 0x10(%rsp), %ecx
cmpl %ecx, 0x50(%rax)
je 0x94ad
movq 0x68(%rax), %rax
testq %rax, %rax
jne 0x8f78
movq 0x10(%r14), %rdx
leaq 0xcf66(%rip), %rsi      # 0x15efb
leaq 0xc313(%rip), %rcx      # 0x152af
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
jmp 0x915d
movq (%r14), %rdx
leaq 0xc8bc(%rip), %rsi      # 0x15874
leaq 0xcf48(%rip), %rcx      # 0x15f07
jmp 0x8971
leaq 0x68(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x43d0
testq %rax, %rax
je 0x934c
movq %rax, %r13
leaq 0x10(%rsp), %r12
xorl %r15d, %r15d
movq 0x18(%r13), %rax
testb $0x4, 0x20(%rax)
jne 0x9023
addq $0x20, %r13
cmpl $0x1, 0xa4(%rbx)
jne 0x9001
movq (%r13), %r13
cmpl $0x3, %ebp
jne 0x9016
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x4460
testl %eax, %eax
je 0x9023
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4050
movq %r12, %rdi
callq 0x4380
movq %rax, %r13
testq %rax, %rax
jne 0x8fe6
jmp 0x915d
movq (%r14), %rdx
leaq 0xc832(%rip), %rsi      # 0x15874
leaq 0xced7(%rip), %rcx      # 0x15f20
jmp 0x92c7
leal -0x70(%r13), %eax
cmpl $0x6, %eax
movq 0x8(%rsp), %rbx
ja 0x911f
leaq 0xcc4d(%rip), %rcx      # 0x15cb4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, 0x8(%rsp)
movslq %r12d, %rbx
leaq 0xcef2(%rip), %rsi      # 0x15f71
movq %r15, %rdi
movq %rbx, %rdx
callq 0x40c0
testl %eax, %eax
je 0x91be
leaq 0xcef6(%rip), %rsi      # 0x15f8f
movq %r15, %rdi
movq %rbx, %rdx
callq 0x40c0
testl %eax, %eax
je 0x9280
cmpl $0x76, %r13d
movq 0x8(%rsp), %rbx
je 0x9109
cmpl $0x74, %r13d
je 0x90e9
cmpl $0x73, %r13d
jne 0x911f
movslq %r12d, %rdx
leaq 0xceda(%rip), %rsi      # 0x15fa7
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x91a1
cmpl $0x76, %r13d
je 0x9109
cmpl $0x74, %r13d
jne 0x911f
movslq %r12d, %rdx
leaq 0xcec4(%rip), %rsi      # 0x15fb7
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x918a
cmpl $0x76, %r13d
jne 0x911f
movslq %r12d, %rdx
leaq 0xcf63(%rip), %rsi      # 0x16076
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x916f
leaq 0xcf39(%rip), %r10      # 0x1605f
leaq 0xc5f0(%rip), %rsi      # 0x1571d
leaq 0xceac(%rip), %rcx      # 0x15fe0
leaq 0xced3(%rip), %r8       # 0x1600e
leaq 0xcee0(%rip), %r9       # 0x16022
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
pushq $0x0
pushq %r10
callq 0x4500
addq $0x10, %rsp
movl $0x1, %r15d
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x4, %ebp
jl 0x91e0
movq (%r14), %rdx
leaq 0xc6f6(%rip), %rsi      # 0x15874
leaq 0xce4a(%rip), %rcx      # 0x15fcf
jmp 0x896e
cmpl $0x2, %ebp
jne 0x926a
movq (%rbx), %rax
movl $0x372e36, (%rax)       # imm = 0x372E36
jmp 0x934c
cmpl $0x2, %ebp
jne 0x92a0
movq 0x198(%rbx), %rax
xorl %r15d, %r15d
testq %rax, %rax
je 0x915d
movq %rax, (%rbx)
jmp 0x915d
cmpl $0x2, %ebp
jne 0x92b6
movq 0x8(%rsp), %rax
movq (%rax), %rax
movw $0x30, 0x4(%rax)
movl $0x2e372e36, (%rax)     # imm = 0x2E372E36
jmp 0x934c
movq 0xc8(%rbx), %rax
movq %rbx, 0x8(%rsp)
leaq 0x68(%rbx), %r12
testq %rax, %rax
cmovneq %rax, %r12
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x43d0
testq %rax, %rax
je 0x934c
movq %rax, %rbx
leaq 0x10(%rsp), %r13
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testb $0x4, 0x20(%rax)
jne 0x9255
addq $0x20, %rbx
cmpl $0x1, 0x3c(%r12)
jne 0x9231
movq (%rbx), %rbx
cmpl $0x3, %ebp
jne 0x9246
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x4460
testl %eax, %eax
je 0x9255
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4050
movq %r13, %rdi
callq 0x4380
movq %rax, %rbx
testq %rax, %rax
jne 0x9218
jmp 0x915d
movq (%r14), %rdx
leaq 0xc600(%rip), %rsi      # 0x15874
leaq 0xcd47(%rip), %rcx      # 0x15fc2
jmp 0x896e
cmpl $0x4, %ebp
movq 0x8(%rsp), %rdi
jl 0x92d1
movq (%r14), %rdx
leaq 0xc5e0(%rip), %rsi      # 0x15874
leaq 0xccfa(%rip), %rcx      # 0x15f95
jmp 0x8971
movq (%r14), %rdx
leaq 0xc5ca(%rip), %rsi      # 0x15874
leaq 0xccfd(%rip), %rcx      # 0x15fae
jmp 0x896e
movq (%r14), %rdx
leaq 0xc5b4(%rip), %rsi      # 0x15874
leaq 0xccb5(%rip), %rcx      # 0x15f7c
movq 0x8(%rsp), %rdi
jmp 0x8971
addq $0x18, %rdi
leaq 0x10(%rsp), %rsi
callq 0x43d0
testq %rax, %rax
je 0x934c
leaq 0x10(%rsp), %r12
xorl %r15d, %r15d
leaq 0x20(%rax), %rbx
movq 0x8(%rsp), %rcx
cmpl $0x1, 0x54(%rcx)
jne 0x92fe
movq (%rbx), %rbx
movq 0x18(%rax), %rdi
callq 0x45e0
testq %rax, %rax
je 0x9330
cmpl $0x3, %ebp
jne 0x9321
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x4460
testl %eax, %eax
je 0x9330
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4050
movq %r12, %rdi
callq 0x4380
testq %rax, %rax
jne 0x92ec
jmp 0x915d
leaq 0xcc44(%rip), %rax      # 0x15f8d
movq %rax, (%rdi)
xorl %r15d, %r15d
jmp 0x915d
movq 0xc8(%rdi), %rdi
xorl %r15d, %r15d
testq %rdi, %rdi
je 0x915d
leaq 0x10(%rsp), %rsi
callq 0x43d0
testq %rax, %rax
je 0x915d
movq %rax, %r13
leaq 0x10(%rsp), %r12
xorl %r15d, %r15d
movq 0x18(%r13), %rax
testb $0x6, 0x20(%rax)
jne 0x93cd
movq 0x8(%rsp), %rax
movq 0xc8(%rax), %rax
addq $0x20, %r13
cmpl $0x1, 0x3c(%rax)
jne 0x93a9
movq (%r13), %r13
cmpl $0x3, %ebp
jne 0x93be
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x4460
testl %eax, %eax
je 0x93cd
movq 0x8(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4050
movq %r12, %rdi
callq 0x4380
movq %rax, %r13
testq %rax, %rax
jne 0x9385
jmp 0x915d
movq 0x10(%r14), %rbx
movq %rbx, %rdi
movl $0x28, %esi
callq 0x4250
testq %rax, %rax
je 0x945a
leaq 0xcb8e(%rip), %rax      # 0x15f8d
movq %rax, (%r12)
jmp 0x915d
movq (%r14), %rdx
leaq 0xc462(%rip), %rsi      # 0x15874
leaq 0xca2f(%rip), %rcx      # 0x15e48
jmp 0x896e
leaq 0xcb05(%rip), %rax      # 0x15f2a
movq %rax, (%rcx)
jmp 0x9157
movq 0x10(%r14), %rdx
movq 0x18(%r14), %r8
subq $0x8, %rsp
leaq 0xca3a(%rip), %rsi      # 0x15e7a
leaq 0xca3f(%rip), %rcx      # 0x15e86
leaq 0xbe61(%rip), %r9       # 0x152af
movq %r15, %rdi
xorl %eax, %eax
pushq $0x0
jmp 0x914e
movq 0xc8(%r12), %rax
leaq 0x40(%rax), %rcx
leaq 0x68(%r12), %rdi
leaq 0xa8(%r12), %rdx
testq %rax, %rax
cmovneq %rcx, %rdx
cmovneq %rax, %rdi
movq %rbx, %rsi
callq *(%rdx)
testq %rax, %rax
je 0x93f8
movq 0x18(%rax), %rax
testb $0x2, 0x20(%rax)
je 0x949e
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
testb $0x1, 0x20(%rax)
jne 0x8d83
jmp 0x93f8
movl 0x54(%rax), %esi
movq 0x58(%rax), %rdx
movq %rbx, %rdi
callq 0x4510
movq %rax, (%rbx)
movq 0x12ada(%rip), %rax     # 0x1bfa0
movq %rax, 0x8(%rbx)
jmp 0x934c
leaq 0xda5d(%rip), %rdx      # 0x16f33
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x4450
testq %rax, %rax
je 0x94f4
leaq 0xcaa1(%rip), %rax      # 0x15f8d
movq %rax, (%r15)
jmp 0x934c
movq 0x20(%r14), %rdx
leaq 0xc9a4(%rip), %rsi      # 0x15ea3
leaq 0xbda9(%rip), %rcx      # 0x152af
movq %r15, %rdi
jmp 0x8971