// File: /workspace/github_c_makefile_star2_O3/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 0x872d
movq (%r14), %rdx
leaq 0xc14c(%rip), %rsi      # 0x14860
leaq 0xc4fe(%rip), %rcx      # 0x14c19
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
jmp 0x8ac9
movl %edx, %ebp
movq 0x8(%r14), %r15
movzbl (%r15), %r13d
movq %r15, %rdi
callq 0x41d0
addl $-0x61, %r13d
cmpl $0x15, %r13d
ja 0x8a91
movq %rax, %r12
leaq 0xc37d(%rip), %rax      # 0x14ad4
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movslq %r12d, %rdx
leaq 0xc4c6(%rip), %rsi      # 0x14c30
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8a91
cmpl $0x3, %ebp
jne 0x8daa
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x44a0
testq %rax, %rax
je 0x8c72
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x90c5
xorl %r15d, %r15d
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4050
movq (%r14), %r14
testq %r14, %r14
jne 0x87a8
jmp 0x8acf
movslq %r12d, %rdx
leaq 0xc705(%rip), %rsi      # 0x14ed2
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8a91
cmpl $0x4, %ebp
jb 0x8c89
movq (%r14), %rdx
leaq 0xc070(%rip), %rsi      # 0x14860
leaq 0xc634(%rip), %rcx      # 0x14e2b
jmp 0x871b
movslq %r12d, %rdx
leaq 0xdb5e(%rip), %rsi      # 0x16364
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8a91
cmpl $0x3, %ebp
jne 0x8d0a
movq 0x10(%r14), %rsi
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4560
testq %rax, %rax
je 0x8f60
leaq 0xc8f9(%rip), %rax      # 0x15139
jmp 0x8f81
movslq %r12d, %rdx
leaq 0xc4ec(%rip), %rsi      # 0x14d3b
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8a91
cmpl $0x4, %ebp
jb 0x8d20
movq (%r14), %rdx
leaq 0xbfee(%rip), %rsi      # 0x14860
leaq 0xc4ca(%rip), %rcx      # 0x14d43
jmp 0x871b
movslq %r12d, %rdx
leaq 0xc040(%rip), %rsi      # 0x148c8
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8a91
cmpl $0x5, %ebp
jne 0x8d94
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x44a0
testq %rax, %rax
je 0x8c72
movq %rax, %r15
addq $0x10, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x9026
movq 0x18(%r14), %rdi
leaq 0x10(%r15), %rsi
callq 0x4320
testl %eax, %eax
jne 0x88bd
movq 0x8(%r15), %rdx
movq 0x20(%r14), %rsi
testq %rdx, %rdx
je 0x90a5
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x4460
testq %rax, %rax
je 0x90cd
leaq 0xc834(%rip), %rax      # 0x15139
jmp 0x90c2
movslq %r12d, %r13
leaq 0xc355(%rip), %rsi      # 0x14c69
movq %r15, %rdi
movq %r13, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
cmpl $0x2, %r12d
setge %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8ae1
cmpl $0x2, %ebp
jne 0x8bbb
movq (%rbx), %rdi
movl 0x190(%rbx), %edx
jmp 0x89e2
movslq %r12d, %rdx
leaq 0xbf6c(%rip), %rsi      # 0x148c3
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8a91
cmpl $0x3, %ebp
jne 0x8dc0
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x44a0
testq %rax, %rax
je 0x8c72
movq 0x8(%rax), %rax
jmp 0x90c2
movslq %r12d, %r13
leaq 0xd622(%rip), %rsi      # 0x15fba
movq %r15, %rdi
movq %r13, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
cmpl $0x2, %r12d
setge %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8b29
cmpl $0x3, %ebp
je 0x8e18
cmpl $0x2, %ebp
jne 0x8e5f
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0x90bb
movq (%rbx), %rdi
movl 0x50(%rax), %edx
leaq 0xb92a(%rip), %rsi      # 0x14313
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x45e0
jmp 0x8acf
movslq %r12d, %r12
leaq 0xc3cb(%rip), %rsi      # 0x14dcd
movq %r15, %rdi
movq %r12, %rdx
callq 0x40c0
testl %eax, %eax
je 0x8b7d
leaq 0xc3cf(%rip), %rsi      # 0x14deb
movq %r15, %rdi
movq %r12, %rdx
callq 0x40c0
testl %eax, %eax
jne 0x8a91
cmpl $0x4, %ebp
jb 0x8ef2
movq (%r14), %rdx
leaq 0xbe22(%rip), %rsi      # 0x14860
leaq 0xc3ac(%rip), %rcx      # 0x14df1
jmp 0x871b
movslq %r12d, %rdx
leaq 0xc3bf(%rip), %rsi      # 0x14e13
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8a91
cmpl $0x2, %ebp
jne 0x8dec
movq (%rbx), %rax
movl $0x372e36, (%rax)       # imm = 0x372E36
jmp 0x90c5
movslq %r12d, %rdx
leaq 0xc382(%rip), %rsi      # 0x14e03
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x8b9a
leaq 0xc423(%rip), %r10      # 0x14ebb
leaq 0xbc7e(%rip), %rsi      # 0x1471d
leaq 0xc396(%rip), %rcx      # 0x14e3c
leaq 0xc3bd(%rip), %r8       # 0x14e6a
leaq 0xc3ca(%rip), %r9       # 0x14e7e
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
pushq $0x0
pushq %r10
callq 0x4510
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
leaq 0xc195(%rip), %rsi      # 0x14c7d
movq %r15, %rdi
movq %r13, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
cmpl $0x4, %r12d
setge %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8bd1
cmpl $0x4, %ebp
jb 0x8e75
movq (%r14), %rdx
leaq 0xbd43(%rip), %rsi      # 0x14860
leaq 0xc162(%rip), %rcx      # 0x14c86
jmp 0x871b
cmpl $0x2, %r12d
setge 0xf(%rsp)
leaq 0xc23b(%rip), %rsi      # 0x14d74
movq %r15, %rdi
movq %r13, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
andb 0xf(%rsp), %al
cmpb $0x1, %al
jne 0x8c29
cmpl $0x2, %ebp
jne 0x8edc
movq 0x288(%rbx), %rax
testq %rax, %rax
jne 0x90c2
leaq 0xc211(%rip), %rax      # 0x14d86
movq %rax, (%rbx)
jmp 0x8ac9
cmpl $0x2, %ebp
jne 0x8dd6
movq (%rbx), %rax
movw $0x30, 0x4(%rax)
movl $0x2e372e36, (%rax)     # imm = 0x2E372E36
jmp 0x90c5
cmpl $0x2, %ebp
jne 0x8e02
movq 0x198(%rbx), %rax
xorl %r15d, %r15d
testq %rax, %rax
jne 0x8f81
jmp 0x8acf
movq (%r14), %rdx
leaq 0xbc9b(%rip), %rsi      # 0x14860
leaq 0xc0a6(%rip), %rcx      # 0x14c72
jmp 0x871b
cmpl $0x4, %r12d
setge %r12b
leaq 0xc0bb(%rip), %rsi      # 0x14c9b
movq %r15, %rdi
movq %r13, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
andb %r12b, %al
cmpb $0x1, %al
jne 0x8a91
cmpl $0x3, %ebp
jne 0x8f89
movq 0x10(%r14), %rdi
callq 0x4500
testl %eax, %eax
leaq 0xc1d3(%rip), %rax      # 0x14de9
leaq 0xc51c(%rip), %rcx      # 0x15139
cmoveq %rax, %rcx
movq %rcx, (%rbx)
jmp 0x90c5
cmpl $0x2, %r12d
setge %r12b
leaq 0xc17b(%rip), %rsi      # 0x14db3
movq %r15, %rdi
movq %r13, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
andb %r12b, %al
cmpb $0x1, %al
jne 0x8a91
cmpl $0x4, %ebp
jb 0x8f9f
movq (%r14), %rdx
leaq 0xbbfa(%rip), %rsi      # 0x14860
leaq 0xc14d(%rip), %rcx      # 0x14dba
jmp 0x871b
movq 0x10(%r14), %rdx
leaq 0xb632(%rip), %rsi      # 0x142af
leaq 0xbfc1(%rip), %rcx      # 0x14c45
jmp 0x871b
movq 0xc8(%rbx), %rax
leaq 0x68(%rbx), %r12
testq %rax, %rax
cmovneq %rax, %r12
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x43e0
testq %rax, %rax
je 0x90c5
movq %rax, %r13
xorl %r15d, %r15d
movq 0x18(%r13), %rax
testb $0x4, 0x20(%rax)
jne 0x8cf3
addq $0x20, %r13
cmpl $0x1, 0x3c(%r12)
jne 0x8cd1
movq (%r13), %r13
cmpl $0x3, %ebp
jne 0x8ce6
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x4470
testl %eax, %eax
je 0x8cf3
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4050
leaq 0x10(%rsp), %rdi
callq 0x4390
movq %rax, %r13
testq %rax, %rax
jne 0x8cb7
jmp 0x8acf
movq (%r14), %rdx
leaq 0xbb4c(%rip), %rsi      # 0x14860
leaq 0xc00f(%rip), %rcx      # 0x14d2a
jmp 0x871b
leaq 0x68(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x43e0
testq %rax, %rax
je 0x90c5
movq %rax, %r13
leaq 0x10(%rsp), %r12
xorl %r15d, %r15d
movq 0x18(%r13), %rax
testb $0x4, 0x20(%rax)
jne 0x8d7f
addq $0x20, %r13
cmpl $0x1, 0xa4(%rbx)
jne 0x8d5d
movq (%r13), %r13
cmpl $0x3, %ebp
jne 0x8d72
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x4470
testl %eax, %eax
je 0x8d7f
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4050
movq %r12, %rdi
callq 0x4390
movq %rax, %r13
testq %rax, %rax
jne 0x8d42
jmp 0x8acf
movq (%r14), %rdx
leaq 0xbac2(%rip), %rsi      # 0x14860
leaq 0xbf12(%rip), %rcx      # 0x14cb7
jmp 0x871b
movq (%r14), %rdx
leaq 0xbaac(%rip), %rsi      # 0x14860
leaq 0xbe7a(%rip), %rcx      # 0x14c35
jmp 0x871b
movq (%r14), %rdx
leaq 0xba96(%rip), %rsi      # 0x14860
leaq 0xbe88(%rip), %rcx      # 0x14c59
jmp 0x871b
movq (%r14), %rdx
leaq 0xba80(%rip), %rsi      # 0x14860
leaq 0xbff1(%rip), %rcx      # 0x14dd8
jmp 0x871b
movq (%r14), %rdx
leaq 0xba6a(%rip), %rsi      # 0x14860
leaq 0xc021(%rip), %rcx      # 0x14e1e
jmp 0x871b
movq (%r14), %rdx
leaq 0xba54(%rip), %rsi      # 0x14860
leaq 0xbff7(%rip), %rcx      # 0x14e0a
jmp 0x871b
movq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x41c0
movl $0x1, %r15d
testl %eax, %eax
jne 0x8acf
movl 0x10(%rsp), %ecx
movq 0xc8(%rbx), %rax
testl %ecx, %ecx
jg 0x9108
testq %rax, %rax
je 0x90e4
addl 0x50(%rax), %ecx
movl %ecx, 0x10(%rsp)
jmp 0x910d
movq (%r14), %rdx
leaq 0xb9f7(%rip), %rsi      # 0x14860
leaq 0xbef3(%rip), %rcx      # 0x14d63
jmp 0x871b
leaq 0x18(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x43e0
testq %rax, %rax
je 0x90c5
movq %rax, %r13
leaq 0x10(%rsp), %r12
xorl %r15d, %r15d
addq $0x20, %r13
cmpl $0x1, 0x54(%rbx)
jne 0x8ea5
movq (%r13), %r13
cmpl $0x3, %ebp
jne 0x8eba
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x4470
testl %eax, %eax
je 0x8ec7
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4050
movq %r12, %rdi
callq 0x4390
movq %rax, %r13
testq %rax, %rax
jne 0x8e97
jmp 0x8acf
movq (%r14), %rdx
leaq 0xb97a(%rip), %rsi      # 0x14860
leaq 0xbe8f(%rip), %rcx      # 0x14d7c
jmp 0x871b
leaq 0x18(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x43e0
testq %rax, %rax
je 0x90c5
leaq 0x10(%rsp), %r12
leaq 0x20(%rax), %r15
cmpl $0x1, 0x54(%rbx)
jne 0x8f1b
movq (%r15), %r15
movq 0x18(%rax), %rdi
callq 0x45f0
testq %rax, %rax
je 0x8f4b
cmpl $0x3, %ebp
jne 0x8f3e
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x4470
testl %eax, %eax
je 0x8f4b
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4050
movq %r12, %rdi
callq 0x4390
xorl %r15d, %r15d
testq %rax, %rax
jne 0x8f0e
jmp 0x8acf
movq 0x10(%r14), %r14
movq %r14, %rdi
movl $0x28, %esi
callq 0x4250
testq %rax, %rax
je 0x9053
leaq 0xbe68(%rip), %rax      # 0x14de9
movq %rax, (%rbx)
jmp 0x8acf
movq (%r14), %rdx
leaq 0xb8cd(%rip), %rsi      # 0x14860
leaq 0xbd0a(%rip), %rcx      # 0x14ca4
jmp 0x871b
movq 0xc8(%rbx), %rdi
xorl %r15d, %r15d
testq %rdi, %rdi
je 0x8acf
leaq 0x10(%rsp), %rsi
callq 0x43e0
testq %rax, %rax
je 0x8acf
movq %rax, %r13
leaq 0x10(%rsp), %r12
xorl %r15d, %r15d
movq 0x18(%r13), %rax
testb $0x6, 0x20(%rax)
jne 0x9011
movq 0xc8(%rbx), %rax
addq $0x20, %r13
cmpl $0x1, 0x3c(%rax)
jne 0x8fef
movq (%r13), %r13
cmpl $0x3, %ebp
jne 0x9004
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x4470
testl %eax, %eax
je 0x9011
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4050
movq %r12, %rdi
callq 0x4390
movq %rax, %r13
testq %rax, %rax
jne 0x8fd0
jmp 0x8acf
movq 0x10(%r14), %rdx
movq 0x18(%r14), %r8
subq $0x8, %rsp
leaq 0xbc9d(%rip), %rsi      # 0x14cd6
leaq 0xbca2(%rip), %rcx      # 0x14ce2
leaq 0xb268(%rip), %r9       # 0x142af
movq %rbx, %rdi
xorl %eax, %eax
pushq $0x0
jmp 0x8ac0
movq 0xc8(%rbx), %rax
leaq 0x40(%rax), %rcx
leaq 0x68(%rbx), %rdi
leaq 0xa8(%rbx), %rdx
testq %rax, %rax
cmovneq %rcx, %rdx
cmovneq %rax, %rdi
movq %r14, %rsi
callq *(%rdx)
testq %rax, %rax
je 0x8f7a
movq 0x18(%rax), %rcx
movl 0x20(%rcx), %eax
testb $0x2, %al
je 0x9098
movq 0x28(%rcx), %rax
movq 0x18(%rax), %rax
movl 0x20(%rax), %eax
testb $0x1, %al
jne 0x8839
jmp 0x8f7a
leaq 0xcb8b(%rip), %rdx      # 0x15c37
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x4460
testq %rax, %rax
je 0x90cd
leaq 0xbd27(%rip), %rax      # 0x14de9
movq %rax, (%rbx)
xorl %r15d, %r15d
jmp 0x8acf
movq 0x20(%r14), %rdx
leaq 0xbc27(%rip), %rsi      # 0x14cff
leaq 0xb1d0(%rip), %rcx      # 0x142af
jmp 0x871b
movq 0x10(%r14), %rdx
leaq 0xbc68(%rip), %rsi      # 0x14d57
leaq 0xb1b9(%rip), %rcx      # 0x142af
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
jmp 0x8acf
testq %rax, %rax
je 0x90e4
cmpl %ecx, 0x50(%rax)
je 0x9118
movq 0x68(%rax), %rax
jmp 0x9108
movl 0x54(%rax), %esi
movq 0x58(%rax), %rdx
movq %rbx, %rdi
callq 0x4520
movq %rax, (%rbx)
movq 0x11e6f(%rip), %rax     # 0x1afa0
movq %rax, 0x8(%rbx)
jmp 0x90c5