LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxAssem.c
// Function: Hax_DeleteCmdBuf
void
Hax_DeleteCmdBuf(
    Hax_Interp *interp,
    Hax_CmdBuf buffer		/* Token for command buffer (return value
				 * from previous call to Hax_CreateCmdBuf). */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    CmdBuf *cbPtr = (CmdBuf *) buffer;

    ckfree(memoryp, cbPtr->buffer);
    ckfree(memoryp, (char *) cbPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
leaq 0x16c55(%rip), %rdx     # 0x1d1f6
movl $0x6c, %ecx
callq 0x4260
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x16c3c(%rip), %rdx     # 0x1d1f6
movl $0x6d, %ecx
callq 0x4260
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxAssem.c
// Function: Hax_CommandComplete
int
Hax_CommandComplete(
    char *cmd			/* Command to check. */)
{
    char *p = cmd;

    p = cmd;
    while (1) {
	while (isspace(*p)) {
	    p++;
	}
	if (*p == 0) {
	    return 1;
	}
	p = HaxWordEnd(p, 0);
	if (*p == 0) {
	    return 0;
	}
	p++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x679e
callq 0x4630
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x67cc
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x679e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x67e1
movl $0x1, -0x4(%rbp)
jmp 0x6813
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x4190
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x6805
movl $0x0, -0x4(%rbp)
jmp 0x6813
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x679c
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxBasic.c
// Function: Hax_CreateCommand
void
Hax_CreateCommand(
    Hax_Interp *interp,		/* Token for command interpreter (returned
				 * by a previous call to Hax_CreateInterp). */
    char *cmdName,		/* Name of command. */
    Hax_CmdProc *proc,		/* Command procedure to associate with
				 * cmdName. */
    ClientData clientData,	/* Arbitrary one-word value to pass to proc. */
    Hax_CmdDeleteProc *deleteProc
				/* If not NULL, gives a procedure to call when
				 * this command is deleted. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Command *cmdPtr;
    Hax_HashEntry *hPtr;
    int newPtr;

    hPtr = Hax_CreateHashEntry(interp, &iPtr->commandTable, cmdName, &newPtr);
    if (!newPtr) {
	/*
	 * Command already exists:  delete the old one.
	 */

	cmdPtr = (Command *) Hax_GetHashValue(hPtr);
	if (cmdPtr->deleteProc != NULL) {
	    (*cmdPtr->deleteProc)(interp, cmdPtr->clientData);
	}
    } else {
	cmdPtr = (Command *) ckalloc(memoryp, sizeof(Command));
	Hax_SetHashValue(hPtr, cmdPtr);
    }
    cmdPtr->proc = proc;
    cmdPtr->clientData = clientData;
    cmdPtr->deleteProc = deleteProc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rdx
leaq -0x4c(%rbp), %rcx
callq *%rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0x4c(%rbp)
jne 0x6f6a
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6f68
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
jmp 0x6f94
movq -0x38(%rbp), %rdi
movl $0x18, %esi
leaq 0x16287(%rip), %rdx     # 0x1d201
movl $0x14f, %ecx            # imm = 0x14F
callq 0x44c0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxBasic.c
// Function: Hax_DeleteCommand
int
Hax_DeleteCommand(
    Hax_Interp *interp,		/* Token for command interpreter (returned
				 * by a previous call to Hax_CreateInterp). */
    char *cmdName		/* Name of command to remove. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Hax_HashEntry *hPtr;
    Command *cmdPtr;

    hPtr = Hax_FindHashEntry(&iPtr->commandTable, cmdName);
    if (hPtr == NULL) {
	return -1;
    }
    cmdPtr = (Command *) Hax_GetHashValue(hPtr);
    if (cmdPtr->deleteProc != NULL) {
	(*cmdPtr->deleteProc)(interp, cmdPtr->clientData);
    }
    ckfree(memoryp, (char *) cmdPtr);
    Hax_DeleteHashEntry(interp, hPtr);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x7011
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x706b
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x703e
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq 0x161b4(%rip), %rdx     # 0x1d201
movl $0x17d, %ecx            # imm = 0x17D
callq 0x4260
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x42d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxBasic.c
// Function: Hax_AddErrorInfo
void
Hax_AddErrorInfo(
    Hax_Interp *interp,		/* Interpreter to which error information
				 * pertains. */
    char *message		/* Message to record. */)
{
    Interp *iPtr = (Interp *) interp;

    /*
     * If an error is already being logged, then the new errorInfo
     * is the concatenation of the old info and the new message.
     * If this is the first piece of info for the error, then the
     * new errorInfo is the concatenation of the message in
     * interp->result and the new message.
     */

    if (!(iPtr->flags & ERR_IN_PROGRESS)) {
	Hax_SetVar2(interp, (char *) "errorInfo", (char *) NULL,
		interp->result, HAX_GLOBAL_ONLY);
	iPtr->flags |= ERR_IN_PROGRESS;

	/*
	 * If the errorCode variable wasn't set by the code that generated
	 * the error, set it to "NONE".
	 */

	if (!(iPtr->flags & ERROR_CODE_SET)) {
	    (void) Hax_SetVar2(interp, (char *) "errorCode", (char *) NULL,
		    (char *) "NONE", HAX_GLOBAL_ONLY);
	}
    }
    Hax_SetVar2(interp, (char *) "errorInfo", (char *) NULL, message,
	    HAX_GLOBAL_ONLY|HAX_APPEND_VALUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x1a0(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x7d73
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rcx
leaq 0x15600(%rip), %rsi     # 0x1d31c
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %r8d
callq 0x40c0
movq -0x18(%rbp), %rax
movl 0x1a0(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x1a0(%rax)
movq -0x18(%rbp), %rax
movl 0x1a0(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x7d71
movq -0x8(%rbp), %rdi
leaq 0x155cb(%rip), %rsi     # 0x1d326
xorl %eax, %eax
movl %eax, %edx
leaq 0x155ca(%rip), %rcx     # 0x1d330
movl $0x1, %r8d
callq 0x40c0
jmp 0x7d73
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq 0x1559a(%rip), %rsi     # 0x1d31c
xorl %eax, %eax
movl %eax, %edx
movl $0x3, %r8d
callq 0x40c0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxBasic.c
// Function: Hax_CreateTrace
Hax_Trace
Hax_CreateTrace(
    Hax_Interp *interp,		/* Interpreter in which to create the trace. */
    int level,			/* Only call proc for commands at nesting level
				 * <= level (1 => top level). */
    Hax_CmdTraceProc *proc,	/* Procedure to call before executing each
				 * command. */
    ClientData clientData	/* Arbitrary one-word value to pass to proc. */)
{
    Trace *tracePtr;
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;

    tracePtr = (Trace *) ckalloc(memoryp, sizeof(Trace));
    tracePtr->level = level;
    tracePtr->proc = proc;
    tracePtr->clientData = clientData;
    tracePtr->nextPtr = iPtr->tracePtr;
    iPtr->tracePtr = tracePtr;

    return (Hax_Trace) tracePtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl $0x20, %esi
leaq 0x15423(%rip), %rdx     # 0x1d201
movl $0x34f, %ecx            # imm = 0x34F
callq 0x44c0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq 0x1a8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x1a8(%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxBasic.c
// Function: Hax_DeleteTrace
void
Hax_DeleteTrace(
    Hax_Interp *interp,		/* Interpreter that contains trace. */
    Hax_Trace trace		/* Token for trace (returned previously by
				 * Hax_CreateTrace). */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Trace *tracePtr = (Trace *) trace;
    Trace *tracePtr2;

    if (iPtr->tracePtr == tracePtr) {
	iPtr->tracePtr = tracePtr->nextPtr;
	ckfree(memoryp, (char *) tracePtr);
    } else {
	for (tracePtr2 = iPtr->tracePtr; tracePtr2 != NULL;
		tracePtr2 = tracePtr2->nextPtr) {
	    if (tracePtr2->nextPtr == tracePtr) {
		tracePtr2->nextPtr = tracePtr->nextPtr;
		ckfree(memoryp, (char *) tracePtr);
		return;
	    }
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x1a8(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x7eae
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x1a8(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x1535f(%rip), %rdx     # 0x1d201
movl $0x377, %ecx            # imm = 0x377
callq 0x4260
jmp 0x7f0f
movq -0x18(%rbp), %rax
movq 0x1a8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x7f0d
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x7efd
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x15310(%rip), %rdx     # 0x1d201
movl $0x37d, %ecx            # imm = 0x37D
callq 0x4260
jmp 0x7f0f
jmp 0x7eff
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x7ebd
jmp 0x7f0f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxBasic.c
// Function: Hax_GlobalEval
int
Hax_GlobalEval(
    Hax_Interp *interp,		/* Interpreter in which to evaluate command. */
    char *command		/* Command to evaluate. */)
{
    Interp *iPtr = (Interp *) interp;
    int result;
    CallFrame *savedVarFramePtr;

    savedVarFramePtr = iPtr->varFramePtr;
    iPtr->varFramePtr = NULL;
    result = Hax_Eval(interp, NULL, command, 0, (char **) NULL);
    iPtr->varFramePtr = savedVarFramePtr;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0xc8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
xorl %ecx, %ecx
movq %r8, %rsi
callq 0x45b0
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xc8(%rax)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxBasic.c
// Function: Hax_SetLibraryPath
void
Hax_SetLibraryPath(
    Hax_Interp *interp,
    char *path)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;

    if (iPtr->libraryPath != NULL) {
	ckfree(memoryp, iPtr->libraryPath);
    }

    iPtr->libraryPath = (char *) ckalloc(memoryp, strlen(path) + 1);
    strcpy(iPtr->libraryPath, path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x288(%rax)
je 0x8335
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x288(%rax), %rsi
leaq 0x14ed6(%rip), %rdx     # 0x1d201
movl $0x45d, %ecx            # imm = 0x45D
callq 0x4260
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
leaq 0x14ea9(%rip), %rdx     # 0x1d201
movl $0x460, %ecx            # imm = 0x460
callq 0x44c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x288(%rax)
movq -0x18(%rbp), %rax
movq 0x288(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40d0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCkalloc.c
// Function: Hax_ValidateAllMemory
void
Hax_ValidateAllMemory (
    Hax_Memoryp *memoryp,
    char  *file,
    int    line)
{
    Memoryp *memCtx = (Memoryp *) memoryp;
    struct mem_header *memScanP;

    for (memScanP = memCtx->allocHead; memScanP != NULL;
	 memScanP = memScanP->flink)
        ValidateMemory (memCtx, memScanP, file, line, FALSE);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x83e2
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %r8d, %r8d
callq 0x83f0
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x83b6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCkalloc.c
// Function: Hax_DumpActiveMemory
int
Hax_DumpActiveMemory (
    Hax_Memoryp *memoryp)
{
    Memoryp           *memCtx = (Memoryp *) memoryp;
    struct mem_header *memScanP;
    char              *address;

    for (memScanP = memCtx->allocHead; memScanP != NULL;
	 memScanP = memScanP->flink) {
        address = &memScanP->body [0];
        printf ("%p - %p  %7ld @ %s %d", address,
                 address + memScanP->length - 1, memScanP->length,
                 memScanP->file, memScanP->line);
        if (strcmp(memScanP->file, "haxHash.c") == 0 && memScanP->line == 514){
	    printf("\t|%s|", ((Hax_HashEntry *) address)->key.string);
	}
	(void) printf("\n");
    }
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8719
movq -0x18(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
addq (%rax), %rdx
addq $-0x1, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x18(%rbp), %rax
movl 0x10(%rax), %r9d
leaq 0x14d52(%rip), %rdi     # 0x1d409
movb $0x0, %al
callq 0x4240
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x14d52(%rip), %rsi     # 0x1d41f
callq 0x4300
cmpl $0x0, %eax
jne 0x86fa
movq -0x18(%rbp), %rax
cmpl $0x202, 0x10(%rax)      # imm = 0x202
jne 0x86fa
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
leaq 0x14d36(%rip), %rdi     # 0x1d429
movb $0x0, %al
callq 0x4240
leaq 0x16863(%rip), %rdi     # 0x1ef64
movb $0x0, %al
callq 0x4240
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x866f
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCkalloc.c
// Function: dump_memory_info
static void
dump_memory_info(
    Memoryp *memoryp)
{
        printf("total mallocs             %10lld\n",
                memoryp->total_mallocs);
        printf("total frees               %10lld\n",
                memoryp->total_frees);
        printf("current packets allocated %10lu\n",
                memoryp->current_malloc_packets);
        printf("current bytes allocated   %10lu\n",
                memoryp->current_bytes_malloced);
        printf("maximum packets allocated %10lu\n",
                memoryp->maximum_malloc_packets);
        printf("maximum bytes allocated   %10lu\n",
                memoryp->maximum_bytes_malloced);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x14c11(%rip), %rdi     # 0x1d5dc
movb $0x0, %al
callq 0x4240
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x14c1d(%rip), %rdi     # 0x1d5fe
movb $0x0, %al
callq 0x4240
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
leaq 0x14c29(%rip), %rdi     # 0x1d620
movb $0x0, %al
callq 0x4240
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x14c34(%rip), %rdi     # 0x1d641
movb $0x0, %al
callq 0x4240
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
leaq 0x14c3f(%rip), %rdi     # 0x1d662
movb $0x0, %al
callq 0x4240
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0x14c4a(%rip), %rdi     # 0x1d683
movb $0x0, %al
callq 0x4240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCkalloc.c
// Function: Hax_DbCkfree
int
Hax_DbCkfree(
    Hax_Memoryp *memoryp,
    void        *ptr,
    char        *file,
    int          line)
{
    Memoryp *memCtx = (Memoryp *) memoryp;
    struct mem_header *memp;

    if (ptr == NULL) {
	Hax_Panic ((char *) "Cannot free memory at addres 0x0, %s line %d",
	    file, line);
    }

    /*
     * Since header ptr is zero, body offset will be size
     */
    memp = (struct mem_header *)(((char *) ptr) -
	offsetof(struct mem_header, body));

    if (memCtx->alloc_tracing)
        printf("ckfree %p %lu %s %d\n", memp->body,
                memp->length, file, line);

    if (memCtx->validate_memory)
        Hax_ValidateAllMemory (memoryp, file, line);

    ValidateMemory (memCtx, memp, file, line, TRUE);

    memCtx->total_frees++;
    memCtx->current_malloc_packets--;
    memCtx->current_bytes_malloced -= memp->length;

    /*
     * Delink from allocated list
     */
    if (memp->flink != NULL)
        memp->flink->blink = memp->blink;
    if (memp->blink != NULL)
        memp->blink->flink = memp->flink;
    if (memCtx->allocHead == memp)
        memCtx->allocHead = memp->flink;
    free((char *) memp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8a8b
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq 0x14a57(%rip), %rdi     # 0x1d4db
movb $0x0, %al
callq 0x4120
movq -0x10(%rbp), %rax
addq $-0x30, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x8ac6
movq -0x30(%rbp), %rsi
addq $0x30, %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
leaq 0x14a49(%rip), %rdi     # 0x1d508
movb $0x0, %al
callq 0x4240
movq -0x28(%rbp), %rax
cmpl $0x0, 0x48(%rax)
je 0x8ae0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x42e0
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl $0x1, %r8d
callq 0x83f0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x8b4f
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x8b6e
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x30(%rbp), %rax
jne 0x8b8a
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
callq 0x4660
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCkalloc.c
// Function: Hax_DbCkrealloc
void *
Hax_DbCkrealloc(
    Hax_Memoryp *memoryp,
    void *ptr,
    unsigned long int size,
    char *file,
    int line)
{
    void *newPtr;

    newPtr = Hax_DbCkalloc(memoryp, size, file, line);
    memcpy(newPtr, ptr, (int) size);
    Hax_DbCkfree(memoryp, ptr, file, line);
    return newPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x44c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq %eax, %rdx
callq 0x4390
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x4260
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCkalloc.c
// Function: Hax_CreateMemoryManagement
Hax_Memoryp *
Hax_CreateMemoryManagement(
    int break_on_malloc,
    int trace_on_at_malloc,
    int alloc_tracing,
    int init_malloced_bodies,
    int validate_memory)
{
    Memoryp *memoryp;

    memoryp = (Memoryp *) malloc(sizeof(Memoryp));
    memset(memoryp, 0, sizeof(Memoryp));

    memoryp->break_on_malloc = break_on_malloc;
    memoryp->trace_on_at_malloc = trace_on_at_malloc;
    memoryp->alloc_tracing = alloc_tracing;
    memoryp->init_malloced_bodies = init_malloced_bodies;
    memoryp->validate_memory = validate_memory;

    return (Hax_Memoryp *) memoryp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl $0x50, %edi
callq 0x4410
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x4290
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x38(%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x3c(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x40(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x44(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x48(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdAH.c
// Function: Hax_BreakCmd
int
Hax_BreakCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    if (argc != 1) {
	Hax_AppendResult(interp, "wrong # args: should be \"",
		argv[0], "\"", (char *) NULL);
	return HAX_ERROR;
    }
    return HAX_BREAK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x1, -0x1c(%rbp)
je 0x90bb
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x148d5(%rip), %rsi     # 0x1d974
leaq 0x141ca(%rip), %rcx     # 0x1d270
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x90c2
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdAH.c
// Function: Hax_CatchCmd
int
Hax_CatchCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    int result;

    if ((argc != 2) && (argc != 3)) {
	Hax_AppendResult(interp, "wrong # args: should be \"",
		argv[0], " command ?varName?\"", (char *) NULL);
	return HAX_ERROR;
    }
    result = Hax_Eval(interp, NULL, argv[1], 0, (char **) NULL);
    if (argc == 3) {
	if (Hax_SetVar(interp, argv[2], interp->result, 0) == NULL) {
	    Hax_SetResult(interp,
		    (char *) "couldn't save command result in variable",
		    HAX_STATIC);
	    return HAX_ERROR;
	}
    }
    Hax_ResetResult(interp);
    sprintf(interp->result, "%d", result);
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0x9474
cmpl $0x3, -0x1c(%rbp)
je 0x9474
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x1451f(%rip), %rsi     # 0x1d974
leaq 0x145ae(%rip), %rcx     # 0x1da0a
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x94ff
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
xorl %eax, %eax
movl %eax, %r8d
xorl %ecx, %ecx
movq %r8, %rsi
callq 0x45b0
movl %eax, -0x2c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jne 0x94d7
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
callq 0x4450
cmpq $0x0, %rax
jne 0x94d5
movq -0x18(%rbp), %rdi
leaq 0x1455b(%rip), %rsi     # 0x1da1e
xorl %eax, %eax
movl %eax, %edx
callq 0x44e0
movl $0x1, -0x4(%rbp)
jmp 0x94ff
jmp 0x94d7
movq -0x18(%rbp), %rdi
callq 0x42b0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %edx
leaq 0x13de3(%rip), %rsi     # 0x1d2d4
movb $0x0, %al
callq 0x45d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdAH.c
// Function: Hax_ConcatCmd
int
Hax_ConcatCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    if (argc == 1) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" arg ?arg ...?\"", (char *) NULL);
	return HAX_ERROR;
    }

    interp->result = Hax_Concat(interp, argc-1, argv+1);
    interp->freeProc = (Hax_FreeProc *) free;
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x955b
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x14435(%rip), %rsi     # 0x1d974
leaq 0x14f66(%rip), %rcx     # 0x1e4ac
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x9592
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
subl $0x1, %esi
movq -0x28(%rbp), %rdx
addq $0x8, %rdx
callq 0x4650
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x19a21(%rip), %rcx     # 0x22fa8
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdAH.c
// Function: Hax_ContinueCmd
int
Hax_ContinueCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    if (argc != 1) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		"\"", (char *) NULL);
	return HAX_ERROR;
    }
    return HAX_CONTINUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x1, -0x1c(%rbp)
je 0x95eb
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x143a5(%rip), %rsi     # 0x1d974
leaq 0x13c9a(%rip), %rcx     # 0x1d270
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x95f2
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdAH.c
// Function: Hax_ErrorCmd
int
Hax_ErrorCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    Interp *iPtr = (Interp *) interp;

    if ((argc < 2) || (argc > 4)) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" message ?errorInfo? ?errorCode?\"", (char *) NULL);
	return HAX_ERROR;
    }
    if ((argc >= 3) && (argv[2][0] != 0)) {
	Hax_AddErrorInfo(interp, argv[2]);
	iPtr->flags |= ERR_ALREADY_LOGGED;
    }
    if (argc == 4) {
	Hax_SetVar2(interp, (char *) "errorCode", (char *) NULL, argv[3],
		HAX_GLOBAL_ONLY);
	iPtr->flags |= ERROR_CODE_SET;
    }
    Hax_SetResult(interp, argv[1], HAX_VOLATILE);
    return HAX_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x2, -0x1c(%rbp)
jl 0x962b
cmpl $0x4, -0x1c(%rbp)
jle 0x965c
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x14337(%rip), %rsi     # 0x1d974
leaq 0x14403(%rip), %rcx     # 0x1da47
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x96f0
cmpl $0x3, -0x1c(%rbp)
jl 0x9696
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9696
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x43f0
movq -0x30(%rbp), %rax
movl 0x1a0(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x1a0(%rax)
cmpl $0x4, -0x1c(%rbp)
jne 0x96d1
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x13c77(%rip), %rsi     # 0x1d326
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %r8d
callq 0x40c0
movq -0x30(%rbp), %rax
movl 0x1a0(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0x1a0(%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq $-0x1, %rdx
callq 0x44e0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdAH.c
// Function: Hax_EvalCmd
int
Hax_EvalCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    int result;
    char *cmd;

    if (argc < 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" arg ?arg ...?\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (argc == 2) {
	result = Hax_Eval(interp, NULL, argv[1], 0, (char **) NULL);
    } else {

	/*
	 * More than one argument:  concatenate them together with spaces
	 * between, then evaluate the result.
	 */

	cmd = Hax_Concat(interp, argc-1, argv+1);
	result = Hax_Eval(interp, NULL, cmd, 0, (char **) NULL);
	ckfree(memoryp, cmd);
    }
    if (result == HAX_ERROR) {
	char msg[60];
	sprintf(msg, "\n    (\"eval\" body line %d)", interp->errorLine);
	Hax_AddErrorInfo(interp, msg);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x38(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0x9768
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x1422b(%rip), %rsi     # 0x1d974
leaq 0x14d5c(%rip), %rcx     # 0x1e4ac
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x9814
cmpl $0x2, -0x1c(%rbp)
jne 0x978e
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
xorl %eax, %eax
movl %eax, %r8d
xorl %ecx, %ecx
movq %r8, %rsi
callq 0x45b0
movl %eax, -0x3c(%rbp)
jmp 0x97dc
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
subl $0x1, %esi
movq -0x28(%rbp), %rdx
addq $0x8, %rdx
callq 0x4650
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
xorl %ecx, %ecx
movq %r8, %rsi
callq 0x45b0
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq 0x14212(%rip), %rdx     # 0x1d9e4
movl $0x196, %ecx            # imm = 0x196
callq 0x4260
cmpl $0x1, -0x3c(%rbp)
jne 0x980e
leaq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x14272(%rip), %rsi     # 0x1da69
movb $0x0, %al
callq 0x45d0
movq -0x18(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x43f0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdAH.c
// Function: Hax_ExprCmd
int
Hax_ExprCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    if (argc != 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" expression\"", (char *) NULL);
	return HAX_ERROR;
    }

    return Hax_ExprString(interp, argv[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0x986b
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x14125(%rip), %rsi     # 0x1d974
leaq 0x1422e(%rip), %rcx     # 0x1da84
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x987f
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4480
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdIL.c
// Function: Hax_IncrCmd
int
Hax_IncrCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    long long int value;
    char *oldString, *result;
    char newString[30];

    if ((argc != 2) && (argc != 3)) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" varName ?increment?\"", (char *) NULL);
	return HAX_ERROR;
    }

    oldString = Hax_GetVar(interp, argv[1], HAX_LEAVE_ERR_MSG);
    if (oldString == NULL) {
	return HAX_ERROR;
    }
    if (Hax_GetLongLong(interp, oldString, &value) != HAX_OK) {
	Hax_AddErrorInfo(interp,
		(char *) "\n    (reading value of variable to increment)");
	return HAX_ERROR;
    }
    if (argc == 2) {
	value += 1;
    } else {
	long long int increment;

	if (Hax_GetLongLong(interp, argv[2], &increment) != HAX_OK) {
	    Hax_AddErrorInfo(interp,
		    (char *) "\n    (reading increment)");
	    return HAX_ERROR;
	}
	value += increment;
    }
    sprintf(newString, "%lld", value);
    result = Hax_SetVar(interp, argv[1], newString, HAX_LEAVE_ERR_MSG);
    if (result == NULL) {
	return HAX_ERROR;
    }
    interp->result = result;
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0xa854
cmpl $0x3, -0x1c(%rbp)
je 0xa854
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x1313f(%rip), %rsi     # 0x1d974
leaq 0x13435(%rip), %rcx     # 0x1dc71
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0xa95c
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x4550
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xa881
movl $0x1, -0x4(%rbp)
jmp 0xa95c
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x45f0
cmpl $0x0, %eax
je 0xa8b3
movq -0x18(%rbp), %rdi
leaq 0x133e5(%rip), %rsi     # 0x1dc87
callq 0x43f0
movl $0x1, -0x4(%rbp)
jmp 0xa95c
cmpl $0x2, -0x1c(%rbp)
jne 0xa8c7
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xa906
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x68(%rbp), %rdx
callq 0x45f0
cmpl $0x0, %eax
je 0xa8fa
movq -0x18(%rbp), %rdi
leaq 0x133c9(%rip), %rsi     # 0x1dcb5
callq 0x43f0
movl $0x1, -0x4(%rbp)
jmp 0xa95c
movq -0x68(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x133b9(%rip), %rsi     # 0x1dcce
movb $0x0, %al
callq 0x45d0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x60(%rbp), %rdx
movl $0x200, %ecx            # imm = 0x200
callq 0x4450
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xa94a
movl $0x1, -0x4(%rbp)
jmp 0xa95c
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdIL.c
// Function: Hax_JoinCmd
int
Hax_JoinCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    char *joinString;
    char **listArgv;
    int listArgc, i;

    if (argc == 2) {
	joinString = (char *) " ";
    } else if (argc == 3) {
	joinString = argv[2];
    } else {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" list ?joinString?\"", (char *) NULL);
	return HAX_ERROR;
    }

    if (Hax_SplitList(interp, argv[1], &listArgc, &listArgv) != HAX_OK) {
	return HAX_ERROR;
    }
    for (i = 0; i < listArgc; i++) {
	if (i == 0) {
	    Hax_AppendResult(interp, listArgv[0], (char *) NULL);
	} else  {
	    Hax_AppendResult(interp, joinString, listArgv[i], (char *) NULL);
	}
    }
    ckfree(memoryp, (char *) listArgv);
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x38(%rbp)
cmpl $0x2, -0x1c(%rbp)
jne 0xbae1
leaq 0x13395(%rip), %rax     # 0x1ee70
movq %rax, -0x40(%rbp)
jmp 0xbb28
cmpl $0x3, -0x1c(%rbp)
jne 0xbaf5
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xbb26
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x11e6d(%rip), %rsi     # 0x1d974
leaq 0x12487(%rip), %rcx     # 0x1df95
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0xbbc8
jmp 0xbb28
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x4c(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x4520
cmpl $0x0, %eax
je 0xbb4f
movl $0x1, -0x4(%rbp)
jmp 0xbbc8
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jge 0xbba8
cmpl $0x0, -0x50(%rbp)
jne 0xbb7c
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x4500
jmp 0xbb9b
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rax
movslq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x4500
jmp 0xbb9d
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0xbb56
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq 0x123f2(%rip), %rdx     # 0x1dfa9
movl $0x26c, %ecx            # imm = 0x26C
callq 0x4260
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdIL.c
// Function: Hax_ListCmd
int
Hax_ListCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    if (argc < 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" arg ?arg ...?\"", (char *) NULL);
	return HAX_ERROR;
    }
    interp->result = Hax_Merge(interp, argc-1, argv+1);
    interp->freeProc = (Hax_FreeProc *) free;
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0xbffb
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x11995(%rip), %rsi     # 0x1d974
leaq 0x124c6(%rip), %rcx     # 0x1e4ac
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0xc032
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
subl $0x1, %esi
movq -0x28(%rbp), %rdx
addq $0x8, %rdx
callq 0x4510
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x16f81(%rip), %rcx     # 0x22fa8
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdIL.c
// Function: Hax_LlengthCmd
int
Hax_LlengthCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    long int count, result;
    char *element, *p;

    if (argc != 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" list\"", (char *) NULL);
	return HAX_ERROR;
    }
    for (count = 0, p = argv[1]; *p != 0 ; count++) {
	result = HaxFindElement(interp, p, &element, &p, (long int *) NULL,
		(int *) NULL);
	if (result != HAX_OK) {
	    return result;
	}
	if (*element == 0) {
	    break;
	}
    }
    sprintf(interp->result, "%ld", count);
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0xc08e
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x11905(%rip), %rsi     # 0x1d974
leaq 0x11f6e(%rip), %rcx     # 0x1dfe4
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0xc11f
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xc0ff
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
callq 0x4350
cltq
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xc0e1
movq -0x38(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0xc11f
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xc0ef
jmp 0xc0ff
jmp 0xc0f1
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xc0a2
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
leaq 0x121c2(%rip), %rsi     # 0x1e2d3
movb $0x0, %al
callq 0x45d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxCmdIL.c
// Function: Hax_LsearchCmd
int
Hax_LsearchCmd(
    ClientData notUsed,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    int listArgc;
    char **listArgv;
    int i, match;

    if (argc != 3) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" list pattern\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (Hax_SplitList(interp, argv[1], &listArgc, &listArgv) != HAX_OK) {
	return HAX_ERROR;
    }
    match = -1;
    for (i = 0; i < listArgc; i++) {
	if (Hax_StringMatch(listArgv[i], argv[2])) {
	    match = i;
	    break;
	}
    }
    sprintf(interp->result, "%d", match);
    ckfree(memoryp, (char *) listArgv);
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x38(%rbp)
cmpl $0x3, -0x1c(%rbp)
je 0xc795
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x111fe(%rip), %rsi     # 0x1d974
leaq 0x11916(%rip), %rcx     # 0x1e093
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0xc840
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x3c(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x4520
cmpl $0x0, %eax
je 0xc7bf
movl $0x1, -0x4(%rbp)
jmp 0xc840
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0xc808
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4460
cmpl $0x0, %eax
je 0xc7fb
movl -0x4c(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0xc808
jmp 0xc7fd
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xc7cd
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0x50(%rbp), %edx
leaq 0x10abb(%rip), %rsi     # 0x1d2d4
movb $0x0, %al
callq 0x45d0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq 0x1177a(%rip), %rdx     # 0x1dfa9
movl $0x45e, %ecx            # imm = 0x45E
callq 0x4260
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)