// File: /workspace/github_c_makefile_star2_O2/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, %r14
movl %ecx, 0x14(%rsp)
movq %rdx, %rbx
movq 0x198(%rdi), %r15
testq %rsi, %rsi
je 0x5dd6
movq %rsi, 0x198(%rdi)
movq 0x280(%rdi), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rdi), %rax
testq %rax, %rax
movq %rdi, 0x8(%rsp)
je 0x5e23
movq (%rdi), %rsi
cmpq 0x151a6(%rip), %rax     # 0x1afa0
je 0x5e03
movq %rsi, %rdi
callq *%rax
jmp 0x5e19
leaq 0xd436(%rip), %rdx      # 0x13240
movq 0x20(%rsp), %rdi
movl $0x1df, %ecx            # imm = 0x1DF
callq 0x4280
movq 0x8(%rsp), %rdi
andq $0x0, 0x8(%rdi)
leaq 0x1b0(%rdi), %rdx
movq %rdx, (%rdi)
movb $0x0, 0x1b0(%rdi)
movl 0xb8(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xb8(%rdi)
cmpl $0x64, %eax
jl 0x5e5d
movl %eax, 0xb8(%rdi)
leaq 0xd409(%rip), %rax      # 0x1325e
movq %rax, (%rdi)
jmp 0x6427
movq %rdx, 0x40(%rsp)
movq %r15, 0x50(%rsp)
leaq 0x100(%rsp), %rax
leaq 0x80(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x1c7(%rsp), %rax
movq %rax, 0x10(%rcx)
movq 0x1514b(%rip), %rax     # 0x1afd8
movq %rax, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
movl 0x14(%rsp), %r15d
andl $0x1, %r15d
negl %r15d
andl $0x5d, %r15d
testq %r14, %r14
leaq 0xa8(%rsp), %rax
cmovneq %r14, %rax
movq %rax, 0x78(%rsp)
movq %rbx, (%rax)
leaq 0x18(%rdi), %rax
movq %rax, 0x70(%rsp)
leaq 0x1a8(%rdi), %rax
movq %rax, 0x68(%rsp)
leaq 0xb0(%rsp), %r12
pushq $0xa
popq %rax
movq %rax, 0x30(%rsp)
leaq 0xed1e(%rip), %rax      # 0x14c07
movq %rax, 0x58(%rsp)
movq 0x150bb(%rip), %rbp     # 0x1afb0
movq %rbx, %r13
movq %rbx, 0x48(%rsp)
movq %rbx, 0x18(%rsp)
movl %r15d, 0x2c(%rsp)
movsbl (%r13), %eax
cmpl %eax, %r15d
je 0x62ef
andb $-0xb, 0x1a0(%rdi)
leaq 0x1(%r13), %rax
movsbq (%r13), %rcx
cmpb $0x1, 0x80(%rbp,%rcx)
je 0x5f3c
movzbl %cl, %ecx
cmpl $0xa, %ecx
je 0x5f3c
cmpl $0x3b, %ecx
jne 0x5f44
incq %r13
incq %rax
jmp 0x5f20
cmpl $0x23, %ecx
jne 0x5f69
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0x5f5a
testl %ecx, %ecx
jne 0x5f64
jmp 0x60a7
cmpb $0x5c, -0x1(%rax)
jne 0x60a4
incq %rax
jmp 0x5f49
leaq 0x1(%r13), %rax
cmpl $0x3b, %ecx
cmovneq %r13, %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rbx
movq %rbx, 0x88(%rsp)
xorl %r14d, %r14d
movq 0x30(%rsp), %rax
movl %eax, %r15d
subl %r14d, %r15d
addl $-0x2, %r15d
movslq %r14d, %rax
leaq (%r12,%rax,8), %rax
movq %r13, %rsi
movl 0x14(%rsp), %edx
movl %r15d, %ecx
movq 0x78(%rsp), %r13
movq %r13, %r8
leaq 0x3c(%rsp), %r9
leaq 0x80(%rsp), %r10
pushq %r10
pushq %rax
callq 0x4100
addq $0x10, %rsp
movq (%r13), %r13
testl %eax, %eax
jne 0x6239
cmpq 0x80(%rsp), %rbx
je 0x6014
testl %r14d, %r14d
movl $0x0, %eax
cmovgl %r14d, %eax
xorl %ecx, %ecx
movq 0x80(%rsp), %rdx
cmpq %rcx, %rax
je 0x6011
movq (%r12,%rcx,8), %rsi
subq %rbx, %rsi
addq %rsi, %rdx
movq %rdx, (%r12,%rcx,8)
incq %rcx
jmp 0x5ff1
movq %rdx, %rbx
movl 0x3c(%rsp), %eax
addl %eax, %r14d
cmpl %r15d, %eax
jl 0x60af
movq 0x30(%rsp), %rax
addl %eax, %eax
movq %rax, 0x30(%rsp)
leaq (,%rax,8), %rsi
movq 0x20(%rsp), %rdi
leaq 0xd1fc(%rip), %rdx      # 0x13240
movl $0x261, %ecx            # imm = 0x261
callq 0x44e0
movq %rax, %r15
testl %r14d, %r14d
movl $0x0, %eax
cmovgl %r14d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x6071
movq (%r12,%rcx,8), %rdx
movq %rdx, (%r15,%rcx,8)
incq %rcx
jmp 0x605f
leaq 0xb0(%rsp), %rax
cmpq %rax, %r12
je 0x6097
movq 0x20(%rsp), %rdi
movq %r12, %rsi
leaq 0xd1b3(%rip), %rdx      # 0x13240
movl $0x266, %ecx            # imm = 0x266
callq 0x4280
movq %r15, %r12
movq 0x8(%rsp), %rdi
jmp 0x5f8c
incq %rax
movq %rax, %r13
jmp 0x5f07
movslq %r14d, %rax
andq $0x0, (%r12,%rax,8)
testl %r14d, %r14d
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %r15d
je 0x5f07
cmpl $0x0, 0x194(%rdi)
jne 0x5f07
andq $0x0, (%r12,%rax,8)
btl $0x8, 0x14(%rsp)
jae 0x60fb
movq 0x18(%rsp), %rax
movq %rax, 0x108(%rdi)
leaq -0x1(%r13), %rax
movq %rax, 0x110(%rdi)
movq %rdi, %rbx
movq (%r12), %rsi
movq 0x70(%rsp), %r15
movq %r15, %rdi
callq *0x58(%rbx)
testq %rax, %rax
jne 0x614e
movq %r15, %rdi
leaq 0xd175(%rip), %rsi      # 0x13291
callq *0x58(%rbx)
testq %rax, %rax
je 0x6445
movl %r14d, %ecx
testl %ecx, %ecx
js 0x6140
movl %ecx, %edx
movq (%r12,%rdx,8), %rdx
leal 0x1(%rcx), %esi
movq %rdx, (%r12,%rsi,8)
decl %ecx
jmp 0x612b
leaq 0xd14a(%rip), %rcx      # 0x13291
movq %rcx, (%r12)
incl %r14d
movq 0x18(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %r15
movq 0x8(%rsp), %rcx
movq (%r15), %r15
testq %r15, %r15
je 0x61b8
movl (%r15), %eax
cmpl 0xb8(%rcx), %eax
jl 0x61b2
movb (%r13), %bl
movb $0x0, (%r13)
movq 0x10(%r15), %rdi
movl 0xb8(%rcx), %edx
movq 0x60(%rsp), %rax
movq (%rax), %r8
movq 0x8(%rax), %r9
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rcx
pushq %r12
pushq %r14
callq *0x8(%r15)
movq 0x18(%rsp), %rcx
addq $0x10, %rsp
movb %bl, (%r13)
addq $0x18, %r15
jmp 0x6161
incl 0x190(%rcx)
movq 0x8(%rcx), %rax
testq %rax, %rax
movl 0x2c(%rsp), %r15d
je 0x6205
cmpq 0x14dcd(%rip), %rax     # 0x1afa0
je 0x61df
movq (%rcx), %rdi
movq %rcx, %rbx
callq *%rax
jmp 0x61fd
movq 0x280(%rcx), %rdi
movq %rcx, %rbx
movq (%rcx), %rsi
leaq 0xd04d(%rip), %rdx      # 0x13240
movl $0x2b4, %ecx            # imm = 0x2B4
callq 0x4280
andq $0x0, 0x8(%rbx)
movq %rbx, %rcx
movq 0x40(%rsp), %rax
movq %rax, (%rcx)
movb $0x0, 0x1b0(%rcx)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
movl %r14d, %edx
movq %r12, %rcx
callq *(%rax)
movq 0x8(%rsp), %rdi
testl %eax, %eax
je 0x5f07
jmp 0x6245
leaq 0xd0d7(%rip), %rcx      # 0x13317
movq %rcx, 0x58(%rsp)
movl %eax, %ebx
leaq 0x100(%rsp), %rax
movq 0x80(%rsp), %rsi
cmpq %rax, %rsi
je 0x6272
leaq 0xcfdd(%rip), %rdx      # 0x13240
movq 0x20(%rsp), %rdi
movl $0x2c3, %ecx            # imm = 0x2C3
callq 0x4280
leaq 0xb0(%rsp), %rax
cmpq %rax, %r12
je 0x6298
leaq 0xcfba(%rip), %rdx      # 0x13240
movq 0x20(%rsp), %rdi
movq %r12, %rsi
movl $0x2c6, %ecx            # imm = 0x2C6
callq 0x4280
movq 0x8(%rsp), %rdi
decl 0xb8(%rdi)
je 0x62bb
movl %ebx, %ebp
movq 0x50(%rsp), %r15
movq 0x48(%rsp), %r14
movq 0x18(%rsp), %r12
jmp 0x633d
xorl %ebp, %ebp
cmpl $0x2, %ebx
cmovnel %ebx, %ebp
cmpl $0x2, %ebp
movq 0x50(%rsp), %r15
movq 0x48(%rsp), %r14
movq 0x18(%rsp), %r12
jb 0x632a
callq 0x42d0
cmpl $0x4, %ebx
je 0x62f6
cmpl $0x3, %ebx
jne 0x6307
leaq 0xcfc4(%rip), %rax      # 0x132b1
jmp 0x62fd
xorl %ebx, %ebx
jmp 0x6247
leaq 0xcfd6(%rip), %rax      # 0x132d3
movq 0x8(%rsp), %rdi
movq %rax, (%rdi)
jmp 0x6327
movq 0x8(%rsp), %rbx
movq 0x40(%rsp), %rdi
movq %rdi, (%rbx)
leaq 0xcfdd(%rip), %rsi      # 0x132f8
movl %ebp, %edx
xorl %eax, %eax
callq 0x45f0
movq %rbx, %rdi
pushq $0x1
popq %rbp
testb $0x1, 0x1a0(%rdi)
je 0x633d
callq 0x4460
movq 0x8(%rsp), %rdi
movl %ebp, %eax
xorl $0x1, %eax
movl 0x1a0(%rdi), %ebx
movl %ebx, %ecx
andl $0x4, %ecx
orl %eax, %ecx
jne 0x6378
movl $0x1, 0x10(%rdi)
movq %r12, %rax
subq %r14, %rax
pushq $0x1
popq %rbp
movq %r14, %rcx
cmpq %r12, %rcx
je 0x6386
cmpb $0xa, (%rcx)
jne 0x6373
incl %ebp
movl %ebp, 0x10(%rdi)
incq %rcx
jmp 0x6364
andl $-0x5, %ebx
movl %ebx, 0x1a0(%rdi)
jmp 0x642a
addq %rax, %r14
callq 0x4660
movq 0x8(%rsp), %rsi
movq (%rax), %rax
movsbq (%r14), %rcx
cmpq $0x3b, %rcx
je 0x63ac
movzwl (%rax,%rcx,2), %edx
andl $0x2000, %edx           # imm = 0x2000
je 0x63bb
cmpb $0xa, %cl
jne 0x63b6
incl %ebp
movl %ebp, 0x10(%rsi)
incq %r14
jmp 0x6396
subl %r12d, %r13d
cmpl $0x97, %r13d
leaq 0xcf4a(%rip), %rax      # 0x13316
movq 0x58(%rsp), %r8
cmovgeq %rax, %r8
movl $0x96, %eax
cmpl %eax, %r13d
cmovgel %eax, %r13d
testb $0x2, %bl
leaq 0xcf30(%rip), %rax      # 0x1331b
leaq 0xcf47(%rip), %rsi      # 0x13339
cmoveq %rax, %rsi
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movl %r13d, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x45f0
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x4420
movq 0x8(%rsp), %rdi
andb $-0x5, 0x1a0(%rdi)
pushq $0x1
popq %rbp
movq %r15, 0x198(%rdi)
movl %ebp, %eax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x42d0
movq (%r12), %rdx
leaq 0xce3c(%rip), %rsi      # 0x13299
leaq 0xce4b(%rip), %rcx      # 0x132af
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rbx
jmp 0x6247