// File: /workspace/github_c_makefile_star2_O3/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 $0x1b8, %rsp            # imm = 0x1B8
movq %r8, %r14
movl %ecx, 0x14(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, %r12
movq 0x198(%rdi), %r15
testq %rsi, %rsi
je 0x624e
movq %rsi, 0x198(%r12)
movq 0x280(%r12), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x6298
movq (%r12), %rsi
cmpq 0x14d30(%rip), %rax     # 0x1afa0
je 0x6279
movq %rsi, %rdi
callq *%rax
jmp 0x628f
leaq 0xdfc0(%rip), %rdx      # 0x14240
movq 0x30(%rsp), %rdi
movl $0x1df, %ecx            # imm = 0x1DF
callq 0x4280
movq $0x0, 0x8(%r12)
leaq 0x1b0(%r12), %rdx
movq %rdx, (%r12)
movb $0x0, 0x1b0(%r12)
movl 0xb8(%r12), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xb8(%r12)
cmpl $0x64, %eax
jl 0x62dd
movl %eax, 0xb8(%r12)
leaq 0xdf8a(%rip), %rax      # 0x1425e
movq %rax, (%r12)
jmp 0x6933
movq %rdx, 0x40(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x1b7(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x14cd5(%rip), %rax     # 0x1afd8
movq %rax, 0x78(%rsp)
movq $0x0, 0x80(%rsp)
movl 0x14(%rsp), %edx
andl $0x1, %edx
negl %edx
andl $0x5d, %edx
testq %r14, %r14
leaq 0x98(%rsp), %rax
cmovneq %r14, %rax
movq 0x28(%rsp), %r14
movq %rax, 0x58(%rsp)
movq %r14, (%rax)
movsbl (%r14), %eax
leaq 0xf8f0(%rip), %rcx      # 0x15c37
movq %rcx, 0x48(%rsp)
movl %edx, 0x38(%rsp)
cmpl %eax, %edx
movq %r15, 0x50(%rsp)
jne 0x6374
leaq 0xa0(%rsp), %rbx
movl $0x0, 0x8(%rsp)
movq %r14, %r13
movq %r14, %rdx
jmp 0x675b
leaq 0x18(%r12), %rbp
movl $0xa, %eax
movq %rax, 0x8(%rsp)
leaq 0xa0(%rsp), %rbx
movq 0x14c1e(%rip), %rdi     # 0x1afb0
movq %r14, %rdx
movq %r14, %r13
movq %r12, 0x20(%rsp)
movq %rbp, 0x88(%rsp)
movl 0x1a0(%r12), %eax
andl $-0xb, %eax
movq %r13, %rsi
movl %eax, 0x1a0(%r12)
incq %r13
movsbq (%rsi), %rcx
cmpb $0x1, 0x80(%rdi,%rcx)
je 0x63d9
movzbl %cl, %ecx
cmpl $0xa, %ecx
je 0x63d9
cmpl $0x3b, %ecx
jne 0x63e1
incq %rsi
incq %r13
jmp 0x63be
cmpl $0x23, %ecx
jne 0x6419
movzbl (%r13), %ecx
cmpl $0xa, %ecx
je 0x63f6
testl %ecx, %ecx
jne 0x63fd
jmp 0x6402
cmpb $0x5c, -0x1(%r13)
jne 0x6406
incq %r13
jmp 0x63e6
xorl %ecx, %ecx
jmp 0x640e
movsbl 0x1(%r13), %ecx
incq %r13
cmpl %ecx, 0x38(%rsp)
jne 0x63b0
jmp 0x672f
leaq 0x1(%rsi), %rax
cmpl $0x3b, %ecx
cmovneq %rsi, %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %r15
movq %r15, 0x68(%rsp)
movq 0x8(%rsp), %rax
leal -0x2(%rax), %ebp
movq %r12, %rdi
movl 0x14(%rsp), %edx
movl %ebp, %ecx
movq 0x58(%rsp), %r13
movq %r13, %r8
leaq 0x3c(%rsp), %r9
leaq 0x60(%rsp), %rax
pushq %rax
pushq %rbx
callq 0x4100
addq $0x10, %rsp
movq (%r13), %r13
testl %eax, %eax
jne 0x6746
xorl %r14d, %r14d
movq 0x60(%rsp), %rcx
cmpq %rcx, %r15
je 0x64aa
testl %r14d, %r14d
movq 0x14b2c(%rip), %rdi     # 0x1afb0
jle 0x64b4
movl %r14d, %eax
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
subq %r15, %rdx
addq 0x60(%rsp), %rdx
movq %rdx, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x648b
movq 0x60(%rsp), %rcx
jmp 0x64b4
movq %r15, %rcx
movq 0x14afc(%rip), %rdi     # 0x1afb0
movl 0x3c(%rsp), %eax
addl %eax, %r14d
cmpl %ebp, %eax
jl 0x6590
movq %rcx, 0x90(%rsp)
movq 0x8(%rsp), %r15
addl %r15d, %r15d
leaq (,%r15,8), %rsi
movq 0x30(%rsp), %rdi
leaq 0xdd59(%rip), %rdx      # 0x14240
movl $0x261, %ecx            # imm = 0x261
callq 0x44d0
movq %rax, %r12
testl %r14d, %r14d
jle 0x650e
movl %r14d, %eax
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
movq %rdx, (%r12,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x64fe
leaq 0xa0(%rsp), %rax
cmpq %rax, %rbx
je 0x6534
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
leaq 0xdd16(%rip), %rdx      # 0x14240
movl $0x266, %ecx            # imm = 0x266
callq 0x4280
movq %r15, 0x8(%rsp)
movl %r15d, %ebp
subl %r14d, %ebp
addl $-0x2, %ebp
movslq %r14d, %rax
leaq (%r12,%rax,8), %rax
movq 0x20(%rsp), %rdi
movq %r13, %rsi
movl 0x14(%rsp), %edx
movl %ebp, %ecx
movq 0x58(%rsp), %rbx
movq %rbx, %r8
leaq 0x3c(%rsp), %r9
leaq 0x60(%rsp), %r10
pushq %r10
pushq %rax
callq 0x4100
addq $0x10, %rsp
movq (%rbx), %r13
movq 0x90(%rsp), %r15
movq %r12, %rbx
testl %eax, %eax
je 0x6470
jmp 0x6739
movslq %r14d, %rax
movq $0x0, (%rbx,%rax,8)
testl %r14d, %r14d
movq 0x20(%rsp), %r12
movq 0x88(%rsp), %rbp
je 0x6716
cmpl $0x0, 0x194(%r12)
jne 0x6716
btl $0x8, 0x14(%rsp)
movq $0x0, (%rbx,%rax,8)
jae 0x65e9
movq 0x18(%rsp), %rax
movq %rax, 0x108(%r12)
leaq -0x1(%r13), %rax
movq %rax, 0x110(%r12)
movq (%rbx), %rsi
movq %rbp, %rdi
callq *0x58(%r12)
testq %rax, %rax
jne 0x6639
movq %rbp, %rdi
leaq 0xdc8e(%rip), %rsi      # 0x14291
callq *0x58(%r12)
testq %rax, %rax
je 0x696c
testl %r14d, %r14d
js 0x662c
movl %r14d, %ecx
incq %rcx
movq -0x8(%rbx,%rcx,8), %rdx
movq %rdx, (%rbx,%rcx,8)
decq %rcx
testl %ecx, %ecx
jg 0x661c
leaq 0xdc5e(%rip), %rcx      # 0x14291
movq %rcx, (%rbx)
incl %r14d
movq 0x18(%rax), %r15
movq 0x1a8(%r12), %r12
testq %r12, %r12
je 0x6697
movl (%r12), %eax
movq 0x20(%rsp), %rcx
cmpl 0xb8(%rcx), %eax
jl 0x6690
movb (%r13), %bpl
movb $0x0, (%r13)
movq 0x10(%r12), %rdi
movq 0x20(%rsp), %rsi
movl 0xb8(%rsi), %edx
movq (%r15), %r8
movq 0x8(%r15), %r9
movq 0x18(%rsp), %rcx
pushq %rbx
pushq %r14
callq *0x8(%r12)
addq $0x10, %rsp
movb %bpl, (%r13)
movq 0x18(%r12), %r12
jmp 0x6645
movq 0x20(%rsp), %r12
incl 0x190(%r12)
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x66e5
cmpq 0x148eb(%rip), %rax     # 0x1afa0
je 0x66bf
movq (%r12), %rdi
callq *%rax
jmp 0x66dc
movq 0x280(%r12), %rdi
movq (%r12), %rsi
leaq 0xdb6e(%rip), %rdx      # 0x14240
movl $0x2b4, %ecx            # imm = 0x2B4
callq 0x4280
movq $0x0, 0x8(%r12)
movq 0x40(%rsp), %rax
movq %rax, (%r12)
movb $0x0, 0x1b0(%r12)
movq 0x8(%r15), %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %rbx, %rcx
callq *(%r15)
testl %eax, %eax
movq 0x148a0(%rip), %rdi     # 0x1afb0
jne 0x6966
movsbl (%r13), %eax
cmpl %eax, 0x38(%rsp)
movq 0x28(%rsp), %r14
movq 0x18(%rsp), %rdx
jne 0x63a5
movl $0x0, 0x8(%rsp)
jmp 0x675b
movq %r12, %rbx
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %r14
movq 0x18(%rsp), %rdx
movl %eax, 0x8(%rsp)
leaq 0xdbc1(%rip), %rax      # 0x14317
movq %rax, 0x48(%rsp)
leaq 0xf0(%rsp), %rax
movq 0x60(%rsp), %rsi
cmpq %rax, %rsi
movq %rdx, %r15
je 0x6789
leaq 0xdac9(%rip), %rdx      # 0x14240
movq 0x30(%rsp), %rdi
movl $0x2c3, %ecx            # imm = 0x2C3
callq 0x4280
movq %r15, %rdx
leaq 0xa0(%rsp), %rax
cmpq %rax, %rbx
je 0x67b2
leaq 0xdaa3(%rip), %rdx      # 0x14240
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
movl $0x2c6, %ecx            # imm = 0x2C6
callq 0x4280
movq %r15, %rdx
decl 0xb8(%r12)
je 0x67c2
movl 0x8(%rsp), %ebp
jmp 0x6836
xorl %ebp, %ebp
movl 0x8(%rsp), %eax
cmpl $0x2, %eax
cmovnel %eax, %ebp
cmpl $0x2, %ebp
jb 0x6820
movq %r12, %rdi
callq 0x42d0
movl 0x8(%rsp), %eax
cmpl $0x4, %eax
je 0x67f2
cmpl $0x3, %eax
jne 0x67ff
leaq 0xdac1(%rip), %rax      # 0x142b1
jmp 0x67f9
leaq 0xdada(%rip), %rax      # 0x142d3
movq %rax, (%r12)
jmp 0x6818
movq 0x40(%rsp), %rdi
movq %rdi, (%r12)
leaq 0xdae9(%rip), %rsi      # 0x142f8
movl %ebp, %edx
xorl %eax, %eax
callq 0x45e0
movl $0x1, %ebp
movq %r15, %rdx
testb $0x1, 0x1a0(%r12)
je 0x6836
movq %r12, %rdi
callq 0x4450
movq %r15, %rdx
movl %ebp, %eax
xorl $0x1, %eax
movl 0x1a0(%r12), %ebx
movl %ebx, %ecx
andl $0x4, %ecx
orl %eax, %ecx
jne 0x693a
movl $0x1, 0x10(%r12)
movq %rdx, %rax
movl $0x1, %ebp
subq %r14, %rax
je 0x6880
movq %r14, %rcx
cmpb $0xa, (%rcx)
jne 0x6875
incl %ebp
movl %ebp, 0x10(%r12)
incq %rcx
cmpq %rdx, %rcx
jne 0x6869
addq %rax, %r14
callq 0x4650
movq (%rax), %rax
movsbq (%r14), %rsi
cmpq $0x3b, %rsi
movq %r15, %rcx
movq 0x50(%rsp), %r15
je 0x68a6
movzwl (%rax,%rsi,2), %edx
andl $0x2000, %edx           # imm = 0x2000
je 0x68cf
incq %r14
cmpb $0xa, %sil
jne 0x68b6
incl %ebp
movl %ebp, 0x10(%r12)
movsbq (%r14), %rsi
incq %r14
cmpq $0x3b, %rsi
je 0x68a9
movzwl (%rax,%rsi,2), %edx
andl $0x2000, %edx           # imm = 0x2000
jne 0x68a9
subl %ecx, %r13d
cmpl $0x97, %r13d
leaq 0xda36(%rip), %rax      # 0x14316
movq 0x48(%rsp), %r8
cmovgeq %rax, %r8
movl $0x96, %eax
cmpl %eax, %r13d
cmovgel %eax, %r13d
testb $0x2, %bl
leaq 0xda1c(%rip), %rax      # 0x1431b
leaq 0xda33(%rip), %rsi      # 0x14339
cmoveq %rax, %rsi
leaq 0xf0(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %edx
xorl %eax, %eax
callq 0x45e0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4410
andb $-0x5, 0x1a0(%r12)
movl $0x1, %ebp
jmp 0x694a
andl $-0x5, %ebx
movl %ebx, 0x1a0(%r12)
movq 0x50(%rsp), %r15
movq %r15, 0x198(%r12)
movl %ebp, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, 0x8(%rsp)
jmp 0x699a
movq %r12, %rdi
callq 0x42d0
movq (%rbx), %rdx
leaq 0xd91b(%rip), %rsi      # 0x14299
leaq 0xd92a(%rip), %rcx      # 0x142af
movq %r12, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, 0x8(%rsp)
movq 0x28(%rsp), %r14
movq 0x18(%rsp), %rdx
jmp 0x675b