// File: /workspace/github_c_makefile_star2_O2/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 $0x38, %rsp
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x1, %edx
jg 0x80b7
movq (%r14), %rdx
leaq 0xb7c2(%rip), %rsi      # 0x13860
leaq 0xbb74(%rip), %rcx      # 0x13c19
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
jmp 0x8452
movl %edx, %ebp
movq 0x8(%r14), %r15
movzbl (%r15), %r13d
movq %r15, %rdi
callq 0x41d0
addl $-0x61, %r13d
cmpl $0x15, %r13d
ja 0x8418
movq %rax, %r12
leaq 0xb9f3(%rip), %rax      # 0x13ad4
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movslq %r12d, %rdx
leaq 0xbb3c(%rip), %rsi      # 0x13c30
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8418
cmpl $0x3, %ebp
jne 0x871f
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x44b0
testq %rax, %rax
je 0x85f9
movq %rax, %r12
addq $0x10, %r12
xorl %r15d, %r15d
movq (%r12), %r12
testq %r12, %r12
je 0x8456
leaq 0x10(%r12), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4050
jmp 0x812c
movslq %r12d, %rdx
leaq 0xbd7e(%rip), %rsi      # 0x13ed2
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8418
cmpl $0x4, %ebp
jb 0x8610
movq (%r14), %rdx
leaq 0xb6e9(%rip), %rsi      # 0x13860
leaq 0xbcad(%rip), %rcx      # 0x13e2b
jmp 0x80a5
movslq %r12d, %rdx
leaq 0xd1a7(%rip), %rsi      # 0x15334
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8418
cmpl $0x3, %ebp
jne 0x8689
movq 0x10(%r14), %rsi
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4570
testq %rax, %rax
je 0x88d9
leaq 0xbf46(%rip), %rax      # 0x1410d
jmp 0x88f8
movslq %r12d, %rdx
leaq 0xbb65(%rip), %rsi      # 0x13d3b
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8418
cmpl $0x4, %ebp
jb 0x869f
movq (%r14), %rdx
leaq 0xb667(%rip), %rsi      # 0x13860
leaq 0xbb43(%rip), %rcx      # 0x13d43
jmp 0x80a5
movslq %r12d, %rdx
leaq 0xb6b9(%rip), %rsi      # 0x138c8
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8418
cmpl $0x5, %ebp
jne 0x8709
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x44b0
testq %rax, %rax
je 0x85f9
movq %rax, %r15
addq $0x10, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x8990
movq 0x18(%r14), %rdi
leaq 0x10(%r15), %rsi
callq 0x4330
testl %eax, %eax
jne 0x8244
movq 0x8(%r15), %rdx
movq 0x20(%r14), %rsi
testq %rdx, %rdx
je 0x8a4f
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x4470
testq %rax, %rax
je 0x8a77
leaq 0xbe81(%rip), %rax      # 0x1410d
jmp 0x8a6c
movslq %r12d, %r13
leaq 0xb9ce(%rip), %rsi      # 0x13c69
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 0x8468
cmpl $0x2, %ebp
jne 0x8542
movq (%rbx), %rdi
movl 0x190(%rbx), %edx
jmp 0x8369
movslq %r12d, %rdx
leaq 0xb5e5(%rip), %rsi      # 0x138c3
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8418
cmpl $0x3, %ebp
jne 0x8735
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x44b0
testq %rax, %rax
je 0x85f9
movq 0x8(%rax), %rax
jmp 0x8a6c
movslq %r12d, %r13
leaq 0xcc6b(%rip), %rsi      # 0x14f8a
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 0x84b0
cmpl $0x3, %ebp
je 0x878d
cmpl $0x2, %ebp
jne 0x87eb
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0x8a65
movq (%rbx), %rdi
movl 0x50(%rax), %edx
leaq 0xafa3(%rip), %rsi      # 0x13313
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x45f0
jmp 0x8456
movslq %r12d, %r12
leaq 0xba44(%rip), %rsi      # 0x13dcd
movq %r15, %rdi
movq %r12, %rdx
callq 0x40c0
testl %eax, %eax
je 0x8504
leaq 0xba48(%rip), %rsi      # 0x13deb
movq %r15, %rdi
movq %r12, %rdx
callq 0x40c0
testl %eax, %eax
jne 0x8418
cmpl $0x4, %ebp
jb 0x8874
movq (%r14), %rdx
leaq 0xb49b(%rip), %rsi      # 0x13860
leaq 0xba25(%rip), %rcx      # 0x13df1
jmp 0x80a5
movslq %r12d, %rdx
leaq 0xba38(%rip), %rsi      # 0x13e13
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x8418
cmpl $0x2, %ebp
jne 0x8761
movq (%rbx), %rax
movl $0x372e36, (%rax)       # imm = 0x372E36
jmp 0x8a6f
movslq %r12d, %rdx
leaq 0xb9fb(%rip), %rsi      # 0x13e03
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
je 0x8521
leaq 0xba9c(%rip), %rax      # 0x13ebb
andq $0x0, 0x8(%rsp)
movq %rax, (%rsp)
leaq 0xb2ed(%rip), %rsi      # 0x1371d
leaq 0xba05(%rip), %rcx      # 0x13e3c
leaq 0xba2c(%rip), %r8       # 0x13e6a
leaq 0xba39(%rip), %r9       # 0x13e7e
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb80e(%rip), %rsi      # 0x13c7d
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 0x8558
cmpl $0x4, %ebp
jb 0x8801
movq (%r14), %rdx
leaq 0xb3bc(%rip), %rsi      # 0x13860
leaq 0xb7db(%rip), %rcx      # 0x13c86
jmp 0x80a5
cmpl $0x2, %r12d
setge 0x1f(%rsp)
leaq 0xb8b4(%rip), %rsi      # 0x13d74
movq %r15, %rdi
movq %r13, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
andb 0x1f(%rsp), %al
cmpb $0x1, %al
jne 0x85b0
cmpl $0x2, %ebp
jne 0x885e
movq 0x288(%rbx), %rax
testq %rax, %rax
jne 0x8a6c
leaq 0xb88a(%rip), %rax      # 0x13d86
movq %rax, (%rbx)
jmp 0x8452
cmpl $0x2, %ebp
jne 0x874b
movq (%rbx), %rax
movw $0x30, 0x4(%rax)
movl $0x2e372e36, (%rax)     # imm = 0x2E372E36
jmp 0x8a6f
cmpl $0x2, %ebp
jne 0x8777
movq 0x198(%rbx), %rax
xorl %r15d, %r15d
testq %rax, %rax
jne 0x88f8
jmp 0x8456
movq (%r14), %rdx
leaq 0xb314(%rip), %rsi      # 0x13860
leaq 0xb71f(%rip), %rcx      # 0x13c72
jmp 0x80a5
cmpl $0x4, %r12d
setge %r12b
leaq 0xb734(%rip), %rsi      # 0x13c9b
movq %r15, %rdi
movq %r13, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
andb %r12b, %al
cmpb $0x1, %al
jne 0x8418
cmpl $0x3, %ebp
jne 0x8900
movq 0x10(%r14), %rdi
callq 0x4510
testl %eax, %eax
leaq 0xb84c(%rip), %rax      # 0x13de9
leaq 0xbb69(%rip), %rcx      # 0x1410d
cmoveq %rax, %rcx
movq %rcx, (%rbx)
jmp 0x8a6f
cmpl $0x2, %r12d
setge %r12b
leaq 0xb7f4(%rip), %rsi      # 0x13db3
movq %r15, %rdi
movq %r13, %rdx
callq 0x40c0
testl %eax, %eax
sete %al
andb %r12b, %al
cmpb $0x1, %al
jne 0x8418
cmpl $0x4, %ebp
jb 0x8916
movq (%r14), %rdx
leaq 0xb273(%rip), %rsi      # 0x13860
leaq 0xb7c6(%rip), %rcx      # 0x13dba
jmp 0x80a5
movq 0x10(%r14), %rdx
leaq 0xacab(%rip), %rsi      # 0x132af
leaq 0xb63a(%rip), %rcx      # 0x13c45
jmp 0x80a5
movq 0xc8(%rbx), %rax
leaq 0x68(%rbx), %r12
testq %rax, %rax
cmovneq %rax, %r12
leaq 0x20(%rsp), %rsi
movq %r12, %rdi
callq 0x43f0
movq %rax, %r13
xorl %r15d, %r15d
testq %r13, %r13
je 0x8456
movq 0x18(%r13), %rax
testb $0x4, 0x20(%rax)
jne 0x867a
addq $0x20, %r13
cmpl $0x1, 0x3c(%r12)
jne 0x8658
movq (%r13), %r13
cmpl $0x3, %ebp
jne 0x866d
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x4480
testl %eax, %eax
je 0x867a
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4050
leaq 0x20(%rsp), %rdi
callq 0x43a0
movq %rax, %r13
jmp 0x8635
movq (%r14), %rdx
leaq 0xb1cd(%rip), %rsi      # 0x13860
leaq 0xb690(%rip), %rcx      # 0x13d2a
jmp 0x80a5
leaq 0x68(%rbx), %rdi
leaq 0x20(%rsp), %r12
movq %r12, %rsi
callq 0x43f0
movq %rax, %r13
xorl %r15d, %r15d
testq %r13, %r13
je 0x8456
movq 0x18(%r13), %rax
testb $0x4, 0x20(%rax)
jne 0x86fc
addq $0x20, %r13
cmpl $0x1, 0xa4(%rbx)
jne 0x86da
movq (%r13), %r13
cmpl $0x3, %ebp
jne 0x86ef
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x4480
testl %eax, %eax
je 0x86fc
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4050
movq %r12, %rdi
callq 0x43a0
movq %rax, %r13
jmp 0x86b6
movq (%r14), %rdx
leaq 0xb14d(%rip), %rsi      # 0x13860
leaq 0xb59d(%rip), %rcx      # 0x13cb7
jmp 0x80a5
movq (%r14), %rdx
leaq 0xb137(%rip), %rsi      # 0x13860
leaq 0xb505(%rip), %rcx      # 0x13c35
jmp 0x80a5
movq (%r14), %rdx
leaq 0xb121(%rip), %rsi      # 0x13860
leaq 0xb513(%rip), %rcx      # 0x13c59
jmp 0x80a5
movq (%r14), %rdx
leaq 0xb10b(%rip), %rsi      # 0x13860
leaq 0xb67c(%rip), %rcx      # 0x13dd8
jmp 0x80a5
movq (%r14), %rdx
leaq 0xb0f5(%rip), %rsi      # 0x13860
leaq 0xb6ac(%rip), %rcx      # 0x13e1e
jmp 0x80a5
movq (%r14), %rdx
leaq 0xb0df(%rip), %rsi      # 0x13860
leaq 0xb682(%rip), %rcx      # 0x13e0a
jmp 0x80a5
movq 0x10(%r14), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x41c0
pushq $0x1
popq %r15
testl %eax, %eax
jne 0x8456
movl 0x20(%rsp), %eax
testl %eax, %eax
jg 0x87c9
movq 0xc8(%rbx), %rcx
testq %rcx, %rcx
je 0x89ba
addl 0x50(%rcx), %eax
movl %eax, 0x20(%rsp)
leaq 0xc8(%rbx), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x89ba
cmpl %eax, 0x50(%rcx)
je 0x89de
addq $0x68, %rcx
jmp 0x87d0
movq (%r14), %rdx
leaq 0xb06b(%rip), %rsi      # 0x13860
leaq 0xb567(%rip), %rcx      # 0x13d63
jmp 0x80a5
leaq 0x18(%rbx), %rdi
leaq 0x20(%rsp), %r12
movq %r12, %rsi
callq 0x43f0
movq %rax, %r13
xorl %r15d, %r15d
testq %r13, %r13
je 0x8456
addq $0x20, %r13
cmpl $0x1, 0x54(%rbx)
jne 0x882f
movq (%r13), %r13
cmpl $0x3, %ebp
jne 0x8844
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x4480
testl %eax, %eax
je 0x8851
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4050
movq %r12, %rdi
callq 0x43a0
movq %rax, %r13
jmp 0x8818
movq (%r14), %rdx
leaq 0xaff8(%rip), %rsi      # 0x13860
leaq 0xb50d(%rip), %rcx      # 0x13d7c
jmp 0x80a5
leaq 0x18(%rbx), %rdi
leaq 0x20(%rsp), %r12
movq %r12, %rsi
callq 0x43f0
xorl %r15d, %r15d
testq %rax, %rax
je 0x8456
leaq 0x20(%rax), %r13
cmpl $0x1, 0x54(%rbx)
jne 0x889f
movq (%r13), %r13
movq 0x18(%rax), %rdi
callq 0x4600
testq %rax, %rax
je 0x88cf
cmpl $0x3, %ebp
jne 0x88c2
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x4480
testl %eax, %eax
je 0x88cf
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4050
movq %r12, %rdi
callq 0x43a0
jmp 0x8888
movq 0x10(%r14), %r14
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x4250
testq %rax, %rax
je 0x89fd
leaq 0xb4f1(%rip), %rax      # 0x13de9
movq %rax, (%rbx)
jmp 0x8456
movq (%r14), %rdx
leaq 0xaf56(%rip), %rsi      # 0x13860
leaq 0xb393(%rip), %rcx      # 0x13ca4
jmp 0x80a5
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x8a6f
leaq 0x20(%rsp), %r12
movq %r12, %rsi
callq 0x43f0
movq %rax, %r13
xorl %r15d, %r15d
testq %r13, %r13
je 0x8456
movq 0x18(%r13), %rax
testb $0x6, 0x20(%rax)
jne 0x8983
movq 0xc8(%rbx), %rax
addq $0x20, %r13
cmpl $0x1, 0x3c(%rax)
jne 0x8961
movq (%r13), %r13
cmpl $0x3, %ebp
jne 0x8976
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x4480
testl %eax, %eax
je 0x8983
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4050
movq %r12, %rdi
callq 0x43a0
movq %rax, %r13
jmp 0x8939
movq 0x10(%r14), %rdx
movq 0x18(%r14), %r8
andq $0x0, (%rsp)
leaq 0xb332(%rip), %rsi      # 0x13cd6
leaq 0xb337(%rip), %rcx      # 0x13ce2
leaq 0xa8fd(%rip), %r9       # 0x132af
movq %rbx, %rdi
jmp 0x844b
movq 0x10(%r14), %rdx
leaq 0xb392(%rip), %rsi      # 0x13d57
leaq 0xa8e3(%rip), %rcx      # 0x132af
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
jmp 0x8456
movl 0x54(%rcx), %esi
movq 0x58(%rcx), %rdx
movq %rbx, %rdi
callq 0x4530
movq %rax, (%rbx)
movq 0x125a9(%rip), %rax     # 0x1afa0
movq %rax, 0x8(%rbx)
jmp 0x8a6f
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 0x88f1
movq 0x18(%rax), %rcx
movl 0x20(%rcx), %eax
testb $0x2, %al
je 0x8a42
movq 0x28(%rcx), %rax
movq 0x18(%rax), %rax
movl 0x20(%rax), %eax
testb $0x1, %al
jne 0x81c0
jmp 0x88f1
leaq 0xc1b1(%rip), %rdx      # 0x14c07
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x4470
testq %rax, %rax
je 0x8a77
leaq 0xb37d(%rip), %rax      # 0x13de9
movq %rax, (%rbx)
xorl %r15d, %r15d
jmp 0x8456
movq 0x20(%r14), %rdx
leaq 0xb27d(%rip), %rsi      # 0x13cff
leaq 0xa826(%rip), %rcx      # 0x132af
jmp 0x80a5