// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %r8, %r15
movl %ecx, 0x1c(%rsp)
movq %rdx, %r14
movq %rdi, %r13
movq 0x198(%rdi), %rbx
testq %rsi, %rsi
je 0x6307
movq %rsi, 0x198(%r13)
movq 0x280(%r13), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%r13), %rax
testq %rax, %rax
je 0x634e
movq (%r13), %rsi
cmpq 0x15c79(%rip), %rax     # 0x1bfa0
je 0x6330
movq %rsi, %rdi
callq *%rax
jmp 0x6346
leaq 0xef09(%rip), %rdx      # 0x15240
movq 0x38(%rsp), %rdi
movl $0x1df, %ecx            # imm = 0x1DF
callq 0x4280
movq $0x0, 0x8(%r13)
leaq 0x1b0(%r13), %rdx
movq %rdx, (%r13)
movb $0x0, 0x1b0(%r13)
movl 0xb8(%r13), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xb8(%r13)
cmpl $0x64, %eax
jl 0x6393
movl %eax, 0xb8(%r13)
leaq 0xeed9(%rip), %rax      # 0x1525e
movq %rax, (%r13)
movl $0x1, %ebp
jmp 0x6af3
movq %rdx, 0x60(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x1c7(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x15c1f(%rip), %rax     # 0x1bfd8
movq %rax, 0x80(%rsp)
movl 0x1c(%rsp), %r11d
andl $0x1, %r11d
negl %r11d
andl $0x5d, %r11d
testq %r15, %r15
leaq 0xa8(%rsp), %rax
cmovneq %r15, %rax
movq $0x0, 0x88(%rsp)
movq %rax, 0xa0(%rsp)
movq %r14, (%rax)
movsbl (%r14), %eax
cmpl %eax, %r11d
movq %r14, %rax
movq %r14, 0x98(%rsp)
jne 0x642a
leaq 0xb0(%rsp), %rbp
leaq 0x10b19(%rip), %rcx     # 0x16f33
movq %rcx, 0x48(%rsp)
xorl %r15d, %r15d
movq %rax, %rsi
jmp 0x690a
leaq 0x18(%r13), %rdi
movl $0xa, %ecx
movq %rcx, 0x50(%rsp)
leaq 0x10af4(%rip), %rcx     # 0x16f33
movq %rcx, 0x48(%rsp)
leaq 0xb0(%rsp), %rbp
movq 0x15b5d(%rip), %r14     # 0x1bfb0
movq %rax, %r12
movq %rax, %rsi
xorl %r15d, %r15d
movq %rdi, 0x90(%rsp)
movq %r12, %rax
movl 0x1a0(%r13), %ecx
andl $-0xb, %ecx
movq %rsi, %r12
movl %ecx, 0x1a0(%r13)
movq %r12, %rdx
movsbq (%r12), %rdi
cmpq $0xa, %rdi
sete %r8b
cmpq $0x3b, %rdi
sete %r9b
movb 0x80(%r14,%rdi), %sil
cmpb $0x1, %sil
sete %r10b
orb %r8b, %r9b
orb %r10b, %r9b
movzbl %r9b, %r12d
addq %rdx, %r12
cmpb $0x1, %sil
je 0x647b
movzbl %dil, %edi
cmpl $0xa, %edi
je 0x647b
cmpl $0x3b, %edi
je 0x647b
cmpb $0x23, (%r12)
jne 0x6531
xorl %r8d, %r8d
cmpl $0xa, %edi
sete %r8b
xorl %r9d, %r9d
cmpl $0x3b, %edi
sete %r9b
xorl %edi, %edi
cmpb $0x1, %sil
sete %dil
cmpq %r8, %rdi
cmovaq %rdi, %r8
cmpq %r9, %r8
cmovbeq %r9, %r8
leaq (%rdx,%r8), %r12
incq %r12
movzbl (%r12), %edx
cmpl $0xa, %edx
je 0x650e
testl %edx, %edx
jne 0x6516
jmp 0x651e
cmpb $0x5c, -0x1(%r12)
jne 0x651b
incq %r12
jmp 0x64fe
incq %r12
movsbl (%r12), %edx
cmpl %edx, %r11d
jne 0x6474
jmp 0x6907
movq %rbp, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r13, 0x30(%rsp)
movq 0x68(%rsp), %r13
movq %r13, 0x70(%rsp)
xorl %r8d, %r8d
movq %r12, %rsi
movq 0x50(%rsp), %rax
movl %eax, %r15d
subl %r8d, %r15d
addl $-0x2, %r15d
movq %r8, %rbp
movslq %r8d, %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl %r15d, %ecx
movq 0xa0(%rsp), %rbx
movq %rbx, %r8
leaq 0x5c(%rsp), %r9
leaq 0x68(%rsp), %r10
pushq %r10
pushq %rax
callq 0x4100
addq $0x10, %rsp
movl %eax, %edi
movq (%rbx), %rsi
movl $0xe, %ebx
testl %eax, %eax
je 0x65c2
leaq 0xed62(%rip), %rax      # 0x15317
movq %rax, 0x48(%rsp)
movq %rbp, %r8
jmp 0x66bc
cmpq 0x68(%rsp), %r13
je 0x65fc
movq %rbp, %r8
testl %r8d, %r8d
movq 0x10(%rsp), %rbp
jle 0x65f5
movl %r8d, %eax
xorl %ecx, %ecx
movq (%rbp,%rcx,8), %rdx
subq %r13, %rdx
addq 0x68(%rsp), %rdx
movq %rdx, (%rbp,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x65db
movq 0x68(%rsp), %r13
jmp 0x6604
movq %rbp, %r8
movq 0x10(%rsp), %rbp
movl 0x5c(%rsp), %eax
addl %eax, %r8d
cmpl %r15d, %eax
jge 0x6626
movslq %r8d, %rax
movq $0x0, (%rbp,%rax,8)
movl $0xd, %ebx
jmp 0x66bc
movl %edi, 0x40(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x50(%rsp), %rax
addl %eax, %eax
movq %rax, 0x50(%rsp)
leaq (,%rax,8), %rsi
movq 0x38(%rsp), %rdi
leaq 0xebf1(%rip), %rdx      # 0x15240
movl $0x261, %ecx            # imm = 0x261
movq %r8, 0x28(%rsp)
callq 0x44c0
movq 0x28(%rsp), %r8
movq %rax, %r15
testl %r8d, %r8d
jle 0x6681
movl %r8d, %eax
xorl %ecx, %ecx
movq (%rbp,%rcx,8), %rdx
movq %rdx, (%r15,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x6670
xorl %ebx, %ebx
leaq 0xb0(%rsp), %rax
cmpq %rax, %rbp
je 0x66ae
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
leaq 0xeba1(%rip), %rdx      # 0x15240
movl $0x266, %ecx            # imm = 0x266
callq 0x4280
movq 0x28(%rsp), %r8
movq %r15, 0x10(%rsp)
movq 0x8(%rsp), %rsi
movl 0x40(%rsp), %edi
testl %ebx, %ebx
je 0x6555
cmpl $0xe, %ebx
je 0x699d
cmpl $0xd, %ebx
movq 0x30(%rsp), %r13
jne 0x6b1f
movl %edi, %r15d
testl %r8d, %r8d
movq 0x10(%rsp), %rbp
je 0x6757
cmpl $0x0, 0x194(%r13)
movq 0x20(%rsp), %rbx
movl 0x18(%rsp), %r11d
movq 0x90(%rsp), %rdi
jne 0x68f9
btl $0x8, 0x1c(%rsp)
movq %r8, 0x28(%rsp)
movslq %r8d, %rax
movq $0x0, (%rbp,%rax,8)
jae 0x6733
movq %r12, 0x108(%r13)
leaq -0x1(%rsi), %rax
movq %rax, 0x110(%r13)
movq %rsi, 0x8(%rsp)
movq (%rbp), %rsi
movq %rdi, %rbx
callq *0x58(%r13)
testq %rax, %rax
je 0x6766
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %r10
jmp 0x6807
movq 0x20(%rsp), %rbx
movl 0x18(%rsp), %r11d
jmp 0x68f9
movq %rbx, %rdi
leaq 0xeb21(%rip), %rsi      # 0x15291
callq *0x58(%r13)
testq %rax, %rax
movq %rax, 0x40(%rsp)
je 0x67b9
movq 0x28(%rsp), %r10
testl %r10d, %r10d
movq 0x20(%rsp), %rbx
js 0x67a2
movl %r10d, %eax
incq %rax
movq -0x8(%rbp,%rax,8), %rcx
movq %rcx, (%rbp,%rax,8)
decq %rax
jg 0x6793
leaq 0xeae8(%rip), %rax      # 0x15291
movq %rax, (%rbp)
incl %r10d
xorl %eax, %eax
movq 0x8(%rsp), %rsi
jmp 0x67fa
movq %r13, %rdi
callq 0x42d0
movq (%rbp), %rdx
movq %r13, %rdi
leaq 0xeaca(%rip), %rsi      # 0x15299
leaq 0xead9(%rip), %rcx      # 0x152af
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0xe, %eax
movl $0x1, %r15d
movq 0x20(%rsp), %rbx
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %r10
testl %eax, %eax
jne 0x6b16
movq 0x40(%rsp), %rax
movq 0x18(%rax), %r15
movq 0x1a8(%r13), %rbx
testq %rbx, %rbx
je 0x686e
movl (%rbx), %eax
cmpl 0xb8(%r13), %eax
jl 0x6868
movb (%rsi), %r13b
movb $0x0, (%rsi)
movq 0x10(%rbx), %rdi
movq 0x30(%rsp), %rax
movl 0xb8(%rax), %edx
movq (%r15), %r8
movq 0x8(%r15), %r9
movq 0x30(%rsp), %rsi
movq %r12, %rcx
pushq %rbp
pushq %r10
movq %r10, %rbp
callq *0x8(%rbx)
movq %rbp, %r10
movq 0x20(%rsp), %rbp
movq 0x18(%rsp), %rsi
addq $0x10, %rsp
movb %r13b, (%rsi)
movq 0x30(%rsp), %r13
movq 0x18(%rbx), %rbx
jmp 0x6812
incl 0x190(%r13)
movq 0x8(%r13), %rax
testq %rax, %rax
movq 0x20(%rsp), %rbx
je 0x68c3
movq %r10, %rbp
cmpq 0x15713(%rip), %rax     # 0x1bfa0
je 0x6897
movq (%r13), %rdi
callq *%rax
jmp 0x68b3
movq 0x280(%r13), %rdi
movq (%r13), %rsi
leaq 0xe997(%rip), %rdx      # 0x15240
movl $0x2b4, %ecx            # imm = 0x2B4
callq 0x4280
movq $0x0, 0x8(%r13)
movq %rbp, %r10
movq 0x10(%rsp), %rbp
movq 0x60(%rsp), %rax
movq %rax, (%r13)
movb $0x0, 0x1b0(%r13)
movq 0x8(%r15), %rdi
movq %r13, %rsi
movl %r10d, %edx
movq %rbp, %rcx
callq *(%r15)
xorl %r15d, %r15d
testl %eax, %eax
movq 0x8(%rsp), %rsi
movl 0x18(%rsp), %r11d
jne 0x6b0e
movsbl (%rsi), %eax
cmpl %eax, %r11d
jne 0x6464
jmp 0x690d
movq %r12, %rsi
movq %rax, %r12
movq %rsi, 0x8(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x100(%rsp), %rax
cmpq %rax, %rsi
je 0x693a
leaq 0xe915(%rip), %rdx      # 0x15240
movq 0x38(%rsp), %rdi
movl $0x2c3, %ecx            # imm = 0x2C3
callq 0x4280
leaq 0xb0(%rsp), %rax
cmpq %rax, %rbp
je 0x6960
leaq 0xe8f2(%rip), %rdx      # 0x15240
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
movl $0x2c6, %ecx            # imm = 0x2C6
callq 0x4280
decl 0xb8(%r13)
je 0x6971
movl %r15d, %ebp
jmp 0x69f1
xorl %ebp, %ebp
cmpl $0x2, %r15d
cmovnel %r15d, %ebp
cmpl $0x2, %ebp
jb 0x69df
movq %r13, %rdi
callq 0x42d0
cmpl $0x4, %r15d
je 0x69b4
cmpl $0x3, %r15d
jne 0x69c1
leaq 0xe916(%rip), %rax      # 0x152b1
jmp 0x69bb
movl %edi, %r15d
movq 0x30(%rsp), %r13
movq 0x20(%rsp), %rbx
movq 0x10(%rsp), %rbp
jmp 0x690d
leaq 0xe918(%rip), %rax      # 0x152d3
movq %rax, (%r13)
jmp 0x69da
movq 0x60(%rsp), %rdi
movq %rdi, (%r13)
leaq 0xe927(%rip), %rsi      # 0x152f8
movl %ebp, %edx
xorl %eax, %eax
callq 0x45d0
movl $0x1, %ebp
testb $0x1, 0x1a0(%r13)
je 0x69f1
movq %r13, %rdi
callq 0x4440
cmpl $0x1, %ebp
jne 0x6aeb
movl 0x1a0(%r13), %r14d
testb $0x4, %r14b
jne 0x6aeb
movl $0x1, 0x10(%r13)
movq %r12, %rax
movq 0x98(%rsp), %r15
subq %r15, %rax
je 0x6a3a
movq %r15, %rcx
cmpb $0xa, (%rcx)
jne 0x6a2f
incl 0x10(%r13)
incq %rcx
cmpq %r12, %rcx
jne 0x6a26
addq %rax, %r15
callq 0x4640
movq (%rax), %rax
movsbq (%r15), %rcx
cmpq $0x3b, %rcx
movq 0x8(%rsp), %rsi
je 0x6a5d
movzwl (%rax,%rcx,2), %edx
andl $0x2000, %edx           # imm = 0x2000
je 0x6a82
incq %r15
cmpb $0xa, %cl
jne 0x6a69
incl 0x10(%r13)
movsbq (%r15), %rcx
incq %r15
cmpq $0x3b, %rcx
je 0x6a60
movzwl (%rax,%rcx,2), %edx
andl $0x2000, %edx           # imm = 0x2000
jne 0x6a60
subl %r12d, %esi
cmpl $0x97, %esi
leaq 0xe884(%rip), %rax      # 0x15316
movq 0x48(%rsp), %r8
cmovgeq %rax, %r8
movl $0x96, %eax
cmpl %eax, %esi
cmovgel %eax, %esi
testb $0x2, %r14b
leaq 0xe86b(%rip), %rax      # 0x1531b
movq %rsi, %rdx
leaq 0xe87f(%rip), %rsi      # 0x15339
cmoveq %rax, %rsi
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x45d0
movq %r13, %rdi
movq %r14, %rsi
callq 0x4400
andb $-0x5, 0x1a0(%r13)
jmp 0x6389
andb $-0x5, 0x1a0(%r13)
movq %rbx, 0x198(%r13)
movl %ebp, %eax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
jmp 0x690d
cmpl $0xe, %eax
je 0x690d
jmp 0x6afa