// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxBasic.c
// Function: Hax_Eval
int
Hax_Eval(
    Hax_Interp *interp,		/* Token for command interpreter (returned
				 * by a previous call to Hax_CreateInterp). */
    char *scriptFile,		/* Optional argument with a descriptive path
				 * of script loaded and passed to cmd. */
    char *cmd,			/* Pointer to HAX command to interpret. */
    int flags,			/* OR-ed combination of flags like
				 * HAX_BRACKET_TERM and HAX_RECORD_BOUNDS. */
    char **termPtr		/* If non-NULL, fill in the address it points
				 * to with the address of the char. just after
				 * the last one that was part of cmd.  See
				 * the man page for details on this. */)
{
    /*
     * The storage immediately below is used to generate a copy
     * of the command, after all argument substitutions.  Pv will
     * contain the argv values passed to the command procedure.
     */

#   define NUM_CHARS 200
    char copyStorage[NUM_CHARS];
    ParseValue pv;
    char *oldBuffer;

    /*
     * This procedure generates an (argv, argc) array for the command,
     * It starts out with stack-allocated space but uses dynamically-
     * allocated storage to increase it if needed.
     */

#   define NUM_ARGS 10
    char *(argStorage[NUM_ARGS]);
    char **argv = argStorage;
    int argc;
    int argSize = NUM_ARGS;

    char *src;			/* Points to current character
					 * in cmd. */
    char termChar;			/* Return when this character is found
					 * (either ']' or '\0').  Zero means
					 * that newlines terminate commands. */
    int result;				/* Return value. */
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    char *oldScriptFile = iPtr->scriptFile;
    Hax_HashEntry *hPtr;
    Command *cmdPtr;
    char *dummy;			/* Make termPtr point here if it was
					 * originally NULL. */
    char *cmdStart;			/* Points to first non-blank char. in
					 * command (used in calling trace
					 * procedures). */
    const char *ellipsis = "";		/* Used in setting errorInfo variable;
					 * set to "..." to indicate that not
					 * all of offending command is included
					 * in errorInfo.  "" means that the
					 * command is all there. */
    Trace *tracePtr;

    /*
     * Set the scriptFile path.
     */
    if (scriptFile)
        iPtr->scriptFile = scriptFile;
    /*
     * Initialize the result to an empty string and clear out any
     * error information.  This makes sure that we return an empty
     * result if there are no commands in the command string.
     */

    Hax_FreeResult(interp);
    iPtr->result = iPtr->resultSpace;
    iPtr->resultSpace[0] = 0;
    result = HAX_OK;

    /*
     * Check depth of nested calls to Hax_Eval:  if this gets too large,
     * it's probably because of an infinite loop somewhere.
     */

    iPtr->numLevels++;
    if (iPtr->numLevels > MAX_NESTING_DEPTH) {
	iPtr->numLevels--;
	iPtr->result =
	    (char *) "too many nested calls to Hax_Eval (infinite loop?)";
	result = HAX_ERROR;
	goto finish;
    }

    /*
     * Initialize the area in which command copies will be assembled.
     */

    pv.buffer = copyStorage;
    pv.end = copyStorage + NUM_CHARS - 1;
    pv.expandProc = HaxExpandParseValue;
    pv.clientData = (ClientData) NULL;

    src = cmd;
    if (flags & HAX_BRACKET_TERM) {
	termChar = ']';
    } else {
	termChar = 0;
    }
    if (termPtr == NULL) {
	termPtr = &dummy;
    }
    *termPtr = src;
    cmdStart = src;

    /*
     * There can be many sub-commands (separated by semi-colons or
     * newlines) in one command string.  This outer loop iterates over
     * individual commands.
     */

    while (*src != termChar) {
	iPtr->flags &= ~(ERR_IN_PROGRESS | ERROR_CODE_SET);

	/*
	 * Skim off leading white space and semi-colons, and skip
	 * comments.
	 */

	while (1) {
	    char c = *src;

	    if ((CHAR_TYPE(c) != HAX_SPACE) && (c != ';') && (c != '\n')) {
		break;
	    }
	    src += 1;
	}
	if (*src == '#') {
	    for (src++; *src != 0; src++) {
		if ((*src == '\n') && (src[-1] != '\\')) {
		    src++;
		    break;
		}
	    }
	    continue;
	}
	cmdStart = src;

	/*
	 * Parse the words of the command, generating the argc and
	 * argv for the command procedure.  May have to call
	 * HaxParseWords several times, expanding the argv array
	 * between calls.
	 */

	pv.next = oldBuffer = pv.buffer;
	argc = 0;
	while (1) {
	    int newArgs, maxArgs;
	    char **newArgv;
	    int i;

	    /*
	     * Note:  the "- 2" below guarantees that we won't use the
	     * last two argv slots here.  One is for a NULL pointer to
	     * mark the end of the list, and the other is to leave room
	     * for inserting the command name "unknown" as the first
	     * argument (see below).
	     */

	    maxArgs = argSize - argc - 2;
	    result = HaxParseWords((Hax_Interp *) iPtr, src, flags,
		    maxArgs, termPtr, &newArgs, &argv[argc], &pv);
	    src = *termPtr;
	    if (result != HAX_OK) {
		ellipsis = "...";
		goto done;
	    }

	    /*
	     * Careful!  Buffer space may have gotten reallocated while
	     * parsing words.  If this happened, be sure to update all
	     * of the older argv pointers to refer to the new space.
	     */

	    if (oldBuffer != pv.buffer) {
		int i;

		for (i = 0; i < argc; i++) {
		    argv[i] = pv.buffer + (argv[i] - oldBuffer);
		}
		oldBuffer = pv.buffer;
	    }
	    argc += newArgs;
	    if (newArgs < maxArgs) {
		argv[argc] = (char *) NULL;
		break;
	    }

	    /*
	     * Args didn't all fit in the current array.  Make it bigger.
	     */

	    argSize *= 2;
	    newArgv = (char **)
		    ckalloc(memoryp, (unsigned) argSize * sizeof(char *));
	    for (i = 0; i < argc; i++) {
		newArgv[i] = argv[i];
	    }
	    if (argv != argStorage) {
		ckfree(memoryp, (char *) argv);
	    }
	    argv = newArgv;
	}

	/*
	 * If this is an empty command (or if we're just parsing
	 * commands without evaluating them), then just skip to the
	 * next command.
	 */

	if ((argc == 0) || iPtr->noEval) {
	    continue;
	}
	argv[argc] = NULL;

	/*
	 * Save information for the history module, if needed.
	 */

	if (flags & HAX_RECORD_BOUNDS) {
	    iPtr->evalFirst = cmdStart;
	    iPtr->evalLast = src-1;
	}

	/*
	 * Find the procedure to execute this command.  If there isn't
	 * one, then see if there is a command "unknown".  If so,
	 * invoke it instead, passing it the words of the original
	 * command as arguments.
	 */

	hPtr = Hax_FindHashEntry(&iPtr->commandTable, argv[0]);
	if (hPtr == NULL) {
	    int i;

	    hPtr = Hax_FindHashEntry(&iPtr->commandTable, (char *) "unknown");
	    if (hPtr == NULL) {
		Hax_ResetResult(interp);
		Hax_AppendResult(interp, "invalid command name: \"",
			argv[0], "\"", (char *) NULL);
		result = HAX_ERROR;
		goto done;
	    }
	    for (i = argc; i >= 0; i--) {
		argv[i+1] = argv[i];
	    }
	    argv[0] = (char *) "unknown";
	    argc++;
	}
	cmdPtr = (Command *) Hax_GetHashValue(hPtr);

	/*
	 * Call trace procedures, if any.
	 */

	for (tracePtr = iPtr->tracePtr; tracePtr != NULL;
		tracePtr = tracePtr->nextPtr) {
	    char saved;

	    if (tracePtr->level < iPtr->numLevels) {
		continue;
	    }
	    saved = *src;
	    *src = 0;
	    (*tracePtr->proc)(tracePtr->clientData, interp, iPtr->numLevels,
		    cmdStart, cmdPtr->proc, cmdPtr->clientData, argc, argv);
	    *src = saved;
	}

	/*
	 * At long last, invoke the command procedure.  Reset the
	 * result to its default empty value first (it could have
	 * gotten changed by earlier commands in the same command
	 * string).
	 */

	iPtr->cmdCount++;
	Hax_FreeResult((Hax_Interp *) iPtr);
	iPtr->result = iPtr->resultSpace;
	iPtr->resultSpace[0] = 0;
	result = (*cmdPtr->proc)(cmdPtr->clientData, interp, argc, argv);
	if (result != HAX_OK) {
	    break;
	}
    }

    /*
     * Free up any extra resources that were allocated.
     */

    done:
    if (pv.buffer != copyStorage) {
	ckfree(memoryp, (char *) pv.buffer);
    }
    if (argv != argStorage) {
	ckfree(memoryp, (char *) argv);
    }
    iPtr->numLevels--;
    if (iPtr->numLevels == 0) {
	if (result == HAX_RETURN) {
	    result = HAX_OK;
	}
	if ((result != HAX_OK) && (result != HAX_ERROR)) {
	    Hax_ResetResult(interp);
	    if (result == HAX_BREAK) {
		iPtr->result = (char *) "invoked \"break\" outside of a loop";
	    } else if (result == HAX_CONTINUE) {
		iPtr->result =
		    (char *) "invoked \"continue\" outside of a loop";
	    } else {
		iPtr->result = iPtr->resultSpace;
		sprintf(iPtr->resultSpace,
		    (char *) "command returned bad code: %d", result);
	    }
	    result = HAX_ERROR;
	}
	if (iPtr->flags & DELETED) {
	    Hax_DeleteInterp(interp);
	}
    }

    /*
     * If an error occurred, record information about what was being
     * executed when the error occurred.
     */

    if ((result == HAX_ERROR) && !(iPtr->flags & ERR_ALREADY_LOGGED)) {
	int numChars;
	char *p;

	/*
	 * Compute the line number where the error occurred.
	 */

	iPtr->errorLine = 1;
	for (p = cmd; p != cmdStart; p++) {
	    if (*p == '\n') {
		iPtr->errorLine++;
	    }
	}
	for ( ; isspace(*p) || (*p == ';'); p++) {
	    if (*p == '\n') {
		iPtr->errorLine++;
	    }
	}

	/*
	 * Figure out how much of the command to print in the error
	 * message (up to a certain number of characters, or up to
	 * the first new-line).
	 */

	numChars = src - cmdStart;
	if (numChars > (NUM_CHARS-50)) {
	    numChars = NUM_CHARS-50;
	    ellipsis = " ...";
	}

	if (!(iPtr->flags & ERR_IN_PROGRESS)) {
	    sprintf(copyStorage, "\n    while executing\n\"%.*s%s\"",
		    numChars, cmdStart, ellipsis);
	} else {
	    sprintf(copyStorage, "\n    invoked from within\n\"%.*s%s\"",
		    numChars, cmdStart, ellipsis);
	}
	Hax_AddErrorInfo(interp, copyStorage);
	iPtr->flags &= ~ERR_ALREADY_LOGGED;
    } else {
	iPtr->flags &= ~ERR_ALREADY_LOGGED;
    }

finish:
    iPtr->scriptFile = oldScriptFile;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x170(%rbp), %rax
movq %rax, -0x178(%rbp)
movl $0xa, -0x180(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x198(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x1a0(%rbp)
movq -0x198(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x1a8(%rbp)
leaq 0x17d81(%rip), %rax     # 0x1ee73
movq %rax, -0x1d0(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7112
movq -0x10(%rbp), %rcx
movq -0x198(%rbp), %rax
movq %rcx, 0x198(%rax)
jmp 0x7114
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7173
movq -0x8(%rbp), %rax
movq 0x1be7e(%rip), %rcx     # 0x22fa8
cmpq %rcx, 0x8(%rax)
jne 0x7156
movq -0x8(%rbp), %rdi
callq 0x4540
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x160b7(%rip), %rdx     # 0x1d201
movl $0x1df, %ecx            # imm = 0x1DF
callq 0x4260
jmp 0x7167
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x7175
movq -0x198(%rbp), %rcx
addq $0x1b0, %rcx            # imm = 0x1B0
movq -0x198(%rbp), %rax
movq %rcx, (%rax)
movq -0x198(%rbp), %rax
movb $0x0, 0x1b0(%rax)
movl $0x0, -0x190(%rbp)
movq -0x198(%rbp), %rax
movl 0xb8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xb8(%rax)
movq -0x198(%rbp), %rax
cmpl $0x64, 0xb8(%rax)
jle 0x7201
movq -0x198(%rbp), %rax
movl 0xb8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xb8(%rax)
movq -0x198(%rbp), %rax
leaq 0x16030(%rip), %rcx     # 0x1d21f
movq %rcx, (%rax)
movl $0x1, -0x190(%rbp)
jmp 0x7c93
leaq -0xf0(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0xf0(%rbp), %rax
addq $0xc8, %rax
addq $-0x1, %rax
movq %rax, -0x108(%rbp)
movq 0x1bdb2(%rip), %rax     # 0x22fe0
movq %rax, -0x100(%rbp)
movq $0x0, -0xf8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x188(%rbp)
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x725f
movb $0x5d, -0x189(%rbp)
jmp 0x7266
movb $0x0, -0x189(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7278
leaq -0x1c0(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x188(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x188(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq -0x188(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x189(%rbp), %ecx
cmpl %ecx, %eax
je 0x793f
movq -0x198(%rbp), %rax
movl 0x1a0(%rax), %ecx
andl $-0xb, %ecx
movl %ecx, 0x1a0(%rax)
movq -0x188(%rbp), %rax
movb (%rax), %al
movb %al, -0x1d9(%rbp)
movsbq -0x1d9(%rbp), %rcx
movq 0x1bcd7(%rip), %rax     # 0x22fb8
movsbl 0x80(%rax,%rcx), %eax
cmpl $0x1, %eax
je 0x7308
movsbl -0x1d9(%rbp), %eax
cmpl $0x3b, %eax
je 0x7308
movsbl -0x1d9(%rbp), %eax
cmpl $0xa, %eax
je 0x7308
jmp 0x731c
movq -0x188(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x188(%rbp)
jmp 0x72c3
movq -0x188(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x739a
movq -0x188(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x188(%rbp)
movq -0x188(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7395
movq -0x188(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x737f
movq -0x188(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x5c, %eax
je 0x737f
movq -0x188(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x188(%rbp)
jmp 0x7395
jmp 0x7381
movq -0x188(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x188(%rbp)
jmp 0x733d
jmp 0x7294
movq -0x188(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq -0x118(%rbp), %rax
movq %rax, -0x120(%rbp)
movq %rax, -0x110(%rbp)
movl $0x0, -0x17c(%rbp)
movl -0x180(%rbp), %eax
subl -0x17c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x1e4(%rbp)
movq -0x198(%rbp), %rdi
movq -0x188(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x1e4(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x178(%rbp), %r10
movslq -0x17c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %r10
leaq -0x1e0(%rbp), %r9
leaq -0x118(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x40e0
movl %eax, -0x190(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x188(%rbp)
cmpl $0x0, -0x190(%rbp)
je 0x7458
leaq 0x15e8c(%rip), %rax     # 0x1d2d8
movq %rax, -0x1d0(%rbp)
jmp 0x7941
movq -0x120(%rbp), %rax
cmpq -0x118(%rbp), %rax
je 0x74d7
movl $0x0, -0x1f8(%rbp)
movl -0x1f8(%rbp), %eax
cmpl -0x17c(%rbp), %eax
jge 0x74c9
movq -0x118(%rbp), %rdx
movq -0x178(%rbp), %rax
movslq -0x1f8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x120(%rbp), %rcx
subq %rcx, %rax
addq %rax, %rdx
movq -0x178(%rbp), %rax
movslq -0x1f8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1f8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f8(%rbp)
jmp 0x7472
movq -0x118(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x1e0(%rbp), %eax
addl -0x17c(%rbp), %eax
movl %eax, -0x17c(%rbp)
movl -0x1e0(%rbp), %eax
cmpl -0x1e4(%rbp), %eax
jge 0x7512
movq -0x178(%rbp), %rax
movslq -0x17c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x75dd
movl -0x180(%rbp), %eax
shll %eax
movl %eax, -0x180(%rbp)
movq -0x1a0(%rbp), %rdi
movl -0x180(%rbp), %eax
movl %eax, %esi
shlq $0x3, %rsi
leaq 0x15cc7(%rip), %rdx     # 0x1d201
movl $0x261, %ecx            # imm = 0x261
callq 0x44c0
movq %rax, -0x1f0(%rbp)
movl $0x0, -0x1f4(%rbp)
movl -0x1f4(%rbp), %eax
cmpl -0x17c(%rbp), %eax
jge 0x7598
movq -0x178(%rbp), %rax
movslq -0x1f4(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x1f0(%rbp), %rax
movslq -0x1f4(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1f4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f4(%rbp)
jmp 0x7555
movq -0x178(%rbp), %rax
leaq -0x170(%rbp), %rcx
cmpq %rcx, %rax
je 0x75ca
movq -0x1a0(%rbp), %rdi
movq -0x178(%rbp), %rsi
leaq 0x15c41(%rip), %rdx     # 0x1d201
movl $0x266, %ecx            # imm = 0x266
callq 0x4260
movq -0x1f0(%rbp), %rax
movq %rax, -0x178(%rbp)
jmp 0x73c7
cmpl $0x0, -0x17c(%rbp)
je 0x75f6
movq -0x198(%rbp), %rax
cmpl $0x0, 0x194(%rax)
je 0x75fb
jmp 0x7294
movq -0x178(%rbp), %rax
movslq -0x17c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x764c
movq -0x1c8(%rbp), %rcx
movq -0x198(%rbp), %rax
movq %rcx, 0x108(%rax)
movq -0x188(%rbp), %rcx
addq $-0x1, %rcx
movq -0x198(%rbp), %rax
movq %rcx, 0x110(%rax)
movq -0x198(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x198(%rbp), %rdi
addq $0x18, %rdi
movq -0x178(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movq %rax, -0x1b0(%rbp)
cmpq $0x0, -0x1b0(%rbp)
jne 0x7762
movq -0x198(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x198(%rbp), %rdi
addq $0x18, %rdi
leaq 0x15bb2(%rip), %rsi     # 0x1d252
callq *%rax
movq %rax, -0x1b0(%rbp)
cmpq $0x0, -0x1b0(%rbp)
jne 0x76f3
movq -0x8(%rbp), %rdi
callq 0x42b0
movq -0x8(%rbp), %rdi
movq -0x178(%rbp), %rax
movq (%rax), %rdx
leaq 0x15b89(%rip), %rsi     # 0x1d25a
leaq 0x15b98(%rip), %rcx     # 0x1d270
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x190(%rbp)
jmp 0x7941
movl -0x17c(%rbp), %eax
movl %eax, -0x1fc(%rbp)
cmpl $0x0, -0x1fc(%rbp)
jl 0x7742
movq -0x178(%rbp), %rax
movslq -0x1fc(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x178(%rbp), %rax
movl -0x1fc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1fc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1fc(%rbp)
jmp 0x76ff
movq -0x178(%rbp), %rax
leaq 0x15b02(%rip), %rcx     # 0x1d252
movq %rcx, (%rax)
movl -0x17c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x17c(%rbp)
movq -0x1b0(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x1b8(%rbp)
movq -0x198(%rbp), %rax
movq 0x1a8(%rax), %rax
movq %rax, -0x1d8(%rbp)
cmpq $0x0, -0x1d8(%rbp)
je 0x784f
movq -0x1d8(%rbp), %rax
movl (%rax), %eax
movq -0x198(%rbp), %rcx
cmpl 0xb8(%rcx), %eax
jge 0x77b4
jmp 0x7838
movq -0x188(%rbp), %rax
movb (%rax), %al
movb %al, -0x1fd(%rbp)
movq -0x188(%rbp), %rax
movb $0x0, (%rax)
movq -0x1d8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x1d8(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x8(%rbp), %rsi
movq -0x198(%rbp), %rcx
movl 0xb8(%rcx), %edx
movq -0x1c8(%rbp), %rcx
movq -0x1b8(%rbp), %r8
movq (%r8), %r8
movq -0x1b8(%rbp), %r9
movq 0x8(%r9), %r9
movl -0x17c(%rbp), %r11d
movq -0x178(%rbp), %r10
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
movb -0x1fd(%rbp), %cl
movq -0x188(%rbp), %rax
movb %cl, (%rax)
movq -0x1d8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x1d8(%rbp)
jmp 0x7789
movq -0x198(%rbp), %rax
movl 0x190(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x190(%rax)
movq -0x198(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x78d9
movq -0x198(%rbp), %rax
movq 0x1b727(%rip), %rcx     # 0x22fa8
cmpq %rcx, 0x8(%rax)
jne 0x78b3
movq -0x198(%rbp), %rdi
callq 0x4540
movq %rax, %rdi
movq -0x198(%rbp), %rax
movq (%rax), %rsi
leaq 0x1595a(%rip), %rdx     # 0x1d201
movl $0x2b4, %ecx            # imm = 0x2B4
callq 0x4260
jmp 0x78ca
movq -0x198(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x198(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x198(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x78db
movq -0x198(%rbp), %rcx
addq $0x1b0, %rcx            # imm = 0x1B0
movq -0x198(%rbp), %rax
movq %rcx, (%rax)
movq -0x198(%rbp), %rax
movb $0x0, 0x1b0(%rax)
movq -0x1b8(%rbp), %rax
movq (%rax), %rax
movq -0x1b8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x8(%rbp), %rsi
movl -0x17c(%rbp), %edx
movq -0x178(%rbp), %rcx
callq *%rax
movl %eax, -0x190(%rbp)
cmpl $0x0, -0x190(%rbp)
je 0x793a
jmp 0x793f
jmp 0x7294
jmp 0x7941
movq -0x118(%rbp), %rax
leaq -0xf0(%rbp), %rcx
cmpq %rcx, %rax
je 0x7973
movq -0x1a0(%rbp), %rdi
movq -0x118(%rbp), %rsi
leaq 0x15898(%rip), %rdx     # 0x1d201
movl $0x2c3, %ecx            # imm = 0x2C3
callq 0x4260
movq -0x178(%rbp), %rax
leaq -0x170(%rbp), %rcx
cmpq %rcx, %rax
je 0x79a5
movq -0x1a0(%rbp), %rdi
movq -0x178(%rbp), %rsi
leaq 0x15866(%rip), %rdx     # 0x1d201
movl $0x2c6, %ecx            # imm = 0x2C6
callq 0x4260
movq -0x198(%rbp), %rax
movl 0xb8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xb8(%rax)
movq -0x198(%rbp), %rax
cmpl $0x0, 0xb8(%rax)
jne 0x7aa3
cmpl $0x2, -0x190(%rbp)
jne 0x79e2
movl $0x0, -0x190(%rbp)
cmpl $0x0, -0x190(%rbp)
je 0x7a83
cmpl $0x1, -0x190(%rbp)
je 0x7a83
movq -0x8(%rbp), %rdi
callq 0x42b0
cmpl $0x3, -0x190(%rbp)
jne 0x7a21
movq -0x198(%rbp), %rax
leaq 0x15856(%rip), %rcx     # 0x1d272
movq %rcx, (%rax)
jmp 0x7a79
cmpl $0x4, -0x190(%rbp)
jne 0x7a3d
movq -0x198(%rbp), %rax
leaq 0x1585c(%rip), %rcx     # 0x1d294
movq %rcx, (%rax)
jmp 0x7a77
movq -0x198(%rbp), %rcx
addq $0x1b0, %rcx            # imm = 0x1B0
movq -0x198(%rbp), %rax
movq %rcx, (%rax)
movq -0x198(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
movl -0x190(%rbp), %edx
leaq 0x15849(%rip), %rsi     # 0x1d2b9
movb $0x0, %al
callq 0x45d0
jmp 0x7a79
movl $0x1, -0x190(%rbp)
movq -0x198(%rbp), %rax
movl 0x1a0(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7aa1
movq -0x8(%rbp), %rdi
callq 0x4440
jmp 0x7aa3
cmpl $0x1, -0x190(%rbp)
jne 0x7c7b
movq -0x198(%rbp), %rax
movl 0x1a0(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x7c7b
movq -0x198(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x210(%rbp)
movq -0x210(%rbp), %rax
cmpq -0x1c8(%rbp), %rax
je 0x7b27
movq -0x210(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x7b11
movq -0x198(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x7b13
movq -0x210(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x210(%rbp)
jmp 0x7ae2
jmp 0x7b29
callq 0x4630
movq (%rax), %rax
movq -0x210(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x211(%rbp)
jne 0x7b6b
movq -0x210(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
sete %al
movb %al, -0x211(%rbp)
movb -0x211(%rbp), %al
testb $0x1, %al
jne 0x7b77
jmp 0x7baf
movq -0x210(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x7b96
movq -0x198(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x7b98
movq -0x210(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x210(%rbp)
jmp 0x7b29
movq -0x188(%rbp), %rax
movq -0x1c8(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x204(%rbp)
cmpl $0x96, -0x204(%rbp)
jle 0x7bea
movl $0x96, -0x204(%rbp)
leaq 0x156f4(%rip), %rax     # 0x1d2d7
movq %rax, -0x1d0(%rbp)
movq -0x198(%rbp), %rax
movl 0x1a0(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x7c2a
leaq -0xf0(%rbp), %rdi
movl -0x204(%rbp), %edx
movq -0x1c8(%rbp), %rcx
movq -0x1d0(%rbp), %r8
leaq 0x156bb(%rip), %rsi     # 0x1d2dc
movb $0x0, %al
callq 0x45d0
jmp 0x7c53
leaq -0xf0(%rbp), %rdi
movl -0x204(%rbp), %edx
movq -0x1c8(%rbp), %rcx
movq -0x1d0(%rbp), %r8
leaq 0x156ae(%rip), %rsi     # 0x1d2fa
movb $0x0, %al
callq 0x45d0
movq -0x8(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x43f0
movq -0x198(%rbp), %rax
movl 0x1a0(%rax), %ecx
andl $-0x5, %ecx
movl %ecx, 0x1a0(%rax)
jmp 0x7c91
movq -0x198(%rbp), %rax
movl 0x1a0(%rax), %ecx
andl $-0x5, %ecx
movl %ecx, 0x1a0(%rax)
jmp 0x7c93
movq -0x1a8(%rbp), %rcx
movq -0x198(%rbp), %rax
movq %rcx, 0x198(%rax)
movl -0x190(%rbp), %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopw (%rax,%rax)