LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x6cd8
leaq 0xc82b(%rip), %rdi      # 0x134f7
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x4140
cmpl $0x0, 0x40(%rbx)
je 0x6cf9
movq -0x30(%r14), %rdx
leaq 0xc83b(%rip), %rdi      # 0x13524
movq %r14, %rsi
movq %r15, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x4260
leaq -0x30(%r14), %r12
cmpl $0x0, 0x48(%rbx)
je 0x6d10
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x4300
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x6889
incq 0x10(%rbx)
decq 0x28(%rbx)
movq -0x30(%r14), %rax
subq %rax, 0x18(%rbx)
movq -0x18(%r14), %rax
movq -0x10(%r14), %rcx
testq %rax, %rax
je 0x6d45
movq %rcx, 0x20(%rax)
testq %rcx, %rcx
je 0x6d4e
movq %rax, 0x18(%rcx)
cmpq %r12, (%rbx)
jne 0x6d5a
movq -0x18(%r14), %rax
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x4690
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rdx, %rsi
movq %rcx, %rdx
movl %r8d, %ecx
callq 0x44e0
movq %rax, %rbp
movslq %r15d, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x43c0
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x4280
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movl %edi, %r12d
pushq $0x1
popq %rdi
pushq $0x50
popq %rsi
callq 0x4310
movl %r12d, 0x38(%rax)
movl %r15d, 0x3c(%rax)
movl %r14d, 0x40(%rax)
movl %ebp, 0x44(%rax)
movl %ebx, 0x48(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %rbx
leal -0x4(%r12), %eax
cmpl $-0x3, %eax
ja 0x7336
movq (%r15), %rdx
leaq 0xc544(%rip), %rsi      # 0x13860
leaq 0xc5d3(%rip), %rcx      # 0x138f6
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %r14
jmp 0x7385
movq 0x8(%r15), %rdx
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45d0
movl %eax, %ebp
cmpl $0x3, %r12d
jne 0x736a
movq 0x10(%r15), %rsi
movq (%rbx), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x4470
testq %rax, %rax
je 0x7391
movq %rbx, %rdi
callq 0x42d0
movq (%rbx), %rdi
leaq 0xbf97(%rip), %rsi      # 0x13313
movl %ebp, %edx
xorl %eax, %eax
callq 0x45f0
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc572(%rip), %rsi      # 0x1390a
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4500
jmp 0x7330
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
cmpl $0x1, %edx
jne 0x73d0
movq (%rcx), %rdx
leaq 0xc4a9(%rip), %rsi      # 0x13860
leaq 0xcf2e(%rip), %rcx      # 0x142ec
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rax
jmp 0x73f3
decl %edx
addq $0x8, %rcx
movq %rbx, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x4680
movq %rax, (%rbx)
movq 0x13bb3(%rip), %rax     # 0x1afa0
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %rbx
leal -0x5(%r15), %eax
cmpl $-0x4, %eax
ja 0x745f
movq (%r14), %rdx
leaq 0xc417(%rip), %rsi      # 0x13860
leaq 0xc4e3(%rip), %rcx      # 0x13933
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
jmp 0x74b2
cmpl $0x3, %r15d
jb 0x74a3
movq 0x10(%r14), %rsi
cmpb $0x0, (%rsi)
je 0x747d
movq %rbx, %rdi
callq 0x4420
orb $0x4, 0x1a0(%rbx)
cmpl $0x4, %r15d
jne 0x74a3
movq 0x18(%r14), %rcx
leaq 0xbed7(%rip), %rsi      # 0x13365
pushq $0x1
popq %r8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x40e0
orb $0x8, 0x1a0(%rbx)
movq 0x8(%r14), %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x4500
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
cmpl $0x1, %edx
jg 0x74f0
movq (%rcx), %rdx
leaq 0xc389(%rip), %rsi      # 0x13860
leaq 0xce0e(%rip), %rcx      # 0x142ec
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
jmp 0x757b
cmpl $0x2, %edx
jne 0x750c
movq 0x8(%rcx), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45d0
movl %eax, %ebp
jmp 0x7554
movq 0x280(%rbx), %r14
decl %edx
addq $0x8, %rcx
movq %rbx, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x4680
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45d0
movl %eax, %ebp
leaq 0xc38c(%rip), %rdx      # 0x138d0
movq %r14, %rdi
movq %r15, %rsi
movl $0x196, %ecx            # imm = 0x196
callq 0x4280
cmpl $0x1, %ebp
jne 0x757e
movl 0x10(%rbx), %edx
leaq 0xc3f2(%rip), %rsi      # 0x13955
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x45f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4420
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxCmdAH.c
// Function: Hax_ForCmd
int
Hax_ForCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    int result, value;

    if (argc != 5) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" start test next command\"", (char *) NULL);
	return HAX_ERROR;
    }

    result = Hax_Eval(interp, NULL, argv[1], 0, (char **) NULL);
    if (result != HAX_OK) {
	if (result == HAX_ERROR) {
	    Hax_AddErrorInfo(interp,
		(char *) "\n    (\"for\" initial command)");
	}
	return result;
    }
    while (1) {
	result = Hax_ExprBoolean(interp, argv[2], &value);
	if (result != HAX_OK) {
	    return result;
	}
	if (!value) {
	    break;
	}
	result = Hax_Eval(interp, NULL, argv[4], 0, (char **) NULL);
	if (result == HAX_CONTINUE) {
	    result = HAX_OK;
	} else if (result != HAX_OK) {
	    if (result == HAX_ERROR) {
		char msg[60];
		sprintf(msg, "\n    (\"for\" body line %d)", interp->errorLine);
		Hax_AddErrorInfo(interp, msg);
	    }
	    break;
	}
	result = Hax_Eval(interp, NULL, argv[3], 0, (char **) NULL);
	if (result == HAX_BREAK) {
	    break;
	} else if (result != HAX_OK) {
	    if (result == HAX_ERROR) {
		Hax_AddErrorInfo(interp,
		    (char *) "\n    (\"for\" loop-end command)");
	    }
	    return result;
	}
    }
    if (result == HAX_BREAK) {
	result = HAX_OK;
    }
    if (result == HAX_OK) {
	Hax_ResetResult(interp);
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x5, %edx
jne 0x7676
movq 0x8(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45d0
cmpl $0x1, %eax
je 0x7696
testl %eax, %eax
jne 0x76a8
leaq 0xc(%rsp), %r15
leaq 0xc1a9(%rip), %r12      # 0x137b0
movq 0x10(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4670
testl %eax, %eax
jne 0x76a8
cmpl $0x0, 0xc(%rsp)
je 0x76b4
movq 0x20(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45d0
cmpl $0x4, %eax
ja 0x76a8
movl %eax, %ecx
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
movq 0x18(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45d0
testl %eax, %eax
je 0x7607
cmpl $0x3, %eax
je 0x76b4
cmpl $0x1, %eax
jne 0x76a8
leaq 0xc35a(%rip), %rsi      # 0x139ce
jmp 0x769d
movq (%r14), %rdx
leaq 0xc1e0(%rip), %rsi      # 0x13860
leaq 0xc2f6(%rip), %rcx      # 0x1397d
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
jmp 0x76a5
leaq 0xc2fa(%rip), %rsi      # 0x13997
movq %rbx, %rdi
callq 0x4420
pushq $0x1
popq %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x42d0
xorl %eax, %eax
jmp 0x76a8
movl 0x10(%rbx), %edx
leaq 0xc2ea(%rip), %rsi      # 0x139b4
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x45f0
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x76a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %rbx
leal -0x4(%r15), %eax
cmpl $-0x3, %eax
ja 0x7fbf
movq (%r14), %rdx
leaq 0xb8ba(%rip), %rsi      # 0x13860
leaq 0xbc0a(%rip), %rcx      # 0x13bb7
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rbp
jmp 0x7ffb
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movl $0x200, %edx            # imm = 0x200
callq 0x4570
pushq $0x1
popq %rbp
testq %rax, %rax
je 0x7ffb
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4610
testl %eax, %eax
je 0x8008
leaq 0xbbda(%rip), %rsi      # 0x13bcd
movq %rbx, %rdi
callq 0x4420
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %r15d
jne 0x8018
movq 0x8(%rsp), %rdx
incq %rdx
jmp 0x8040
movq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x4610
testl %eax, %eax
je 0x8036
leaq 0xbbc7(%rip), %rsi      # 0x13bfb
jmp 0x7ff3
movq 0x8(%rsp), %rdx
addq 0x10(%rsp), %rdx
movq %rdx, 0x8(%rsp)
leaq 0xbbc8(%rip), %rsi      # 0x13c14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x45f0
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movl $0x200, %ecx            # imm = 0x200
callq 0x4470
testq %rax, %rax
je 0x7ffb
movq %rax, (%rbx)
xorl %ebp, %ebp
jmp 0x7ffb
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x280(%rsi), %r14
cmpl $0x2, %edx
je 0x8ab3
cmpl $0x3, %edx
jne 0x8b14
movq 0x10(%rcx), %r15
jmp 0x8aba
leaq 0xc14a(%rip), %r15      # 0x14c04
movq 0x8(%rcx), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x4540
testl %eax, %eax
jne 0x8b32
xorl %r12d, %r12d
movslq 0xc(%rsp), %rax
cmpq %rax, %r12
jge 0x8b37
movq 0x10(%rsp), %rax
testq %r12, %r12
je 0x8b00
movq (%rax,%r12,8), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x4520
jmp 0x8b0f
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x4520
incq %r12
jmp 0x8ad7
movq (%rcx), %rdx
leaq 0xad42(%rip), %rsi      # 0x13860
leaq 0xb3b2(%rip), %rcx      # 0x13ed7
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rax
jmp 0x8b52
movq 0x10(%rsp), %rsi
leaq 0xb3a8(%rip), %rdx      # 0x13eeb
movq %r14, %rdi
movl $0x26c, %ecx            # imm = 0x26C
callq 0x4280
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxCmdIL.c
// Function: Hax_LindexCmd
int
Hax_LindexCmd(
    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 *p, *element;
    int parenthesized, result;
    long int index, size;

    if (argc != 3) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" list index\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (Hax_GetLong(interp, argv[2], &index) != HAX_OK) {
	return HAX_ERROR;
    }
    if (index < 0) {
	return HAX_OK;
    }
    for (p = argv[1] ; index >= 0; index--) {
	result = HaxFindElement(interp, p, &element, &p, &size,
		&parenthesized);
	if (result != HAX_OK) {
	    return result;
	}
    }
    if (size == 0) {
	return HAX_OK;
    }
    if (size >= HAX_RESULT_SIZE) {
	interp->result = (char *) ckalloc(memoryp, (unsigned) size+1);
	interp->freeProc = (Hax_FreeProc *) free;
    }
    if (parenthesized) {
	memcpy(interp->result, element, size);
	interp->result[size] = 0;
    } else {
	HaxCopyAndCollapse(size, element, interp->result);
    }
    return HAX_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rsi, %r14
cmpl $0x3, %edx
jne 0x8bfd
movq 0x280(%r14), %r12
movq 0x10(%r15), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x8c1b
movq 0x10(%rsp), %rax
xorl %ebx, %ebx
testq %rax, %rax
js 0x8c1e
movq %r12, 0x28(%rsp)
movq 0x8(%r15), %rcx
leaq 0x30(%rsp), %r12
movq %rcx, (%r12)
leaq 0x20(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x1c(%rsp), %r15
testq %rax, %rax
js 0x8c2f
movq 0x30(%rsp), %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %r12, %rcx
movq %rbp, %r8
movq %r15, %r9
callq 0x4380
testl %eax, %eax
jne 0x8c8f
movq 0x10(%rsp), %rax
decq %rax
movq %rax, 0x10(%rsp)
jmp 0x8bc8
movq (%r15), %rdx
leaq 0xac59(%rip), %rsi      # 0x13860
leaq 0xb2e8(%rip), %rcx      # 0x13ef6
movq %r14, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x8c1e
cmpq $0xc7, %rsi
jl 0x8c68
incl %esi
leaq 0xb2a0(%rip), %rdx      # 0x13eeb
movq 0x28(%rsp), %rdi
movl $0x2a5, %ecx            # imm = 0x2A5
callq 0x44e0
movq %rax, (%r14)
movq 0x1233c(%rip), %rax     # 0x1afa0
movq %rax, 0x8(%r14)
cmpl $0x0, 0x1c(%rsp)
je 0x8c93
movq (%r14), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x43c0
movq (%r14), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x8c1e
movl %eax, %ebx
jmp 0x8c1e
movl 0x8(%rsp), %edi
movq 0x20(%rsp), %rsi
movq (%r14), %rdx
callq 0x4160
jmp 0x8c1e
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
cmpl $0x1, %edx
jg 0x8e4f
movq (%rcx), %rdx
leaq 0xaa2a(%rip), %rsi      # 0x13860
leaq 0xb4af(%rip), %rcx      # 0x142ec
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rax
jmp 0x8e72
decl %edx
addq $0x8, %rcx
movq %rbx, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x4530
movq %rax, (%rbx)
movq 0x12134(%rip), %rax     # 0x1afa0
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x2, %edx
jne 0x8eca
movq 0x8(%rcx), %rsi
movq %rsp, %r15
movq %rsi, (%r15)
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
cmpb $0x0, (%rsi)
je 0x8eed
movq %rbx, %rdi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4380
testl %eax, %eax
jne 0x8f05
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x8eed
incq %r14
movq (%rsp), %rsi
jmp 0x8e9a
movq (%rcx), %rdx
leaq 0xa98c(%rip), %rsi      # 0x13860
leaq 0xb04b(%rip), %rcx      # 0x13f26
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rbp
jmp 0x8f07
movq (%rbx), %rdi
leaq 0xb21c(%rip), %rsi      # 0x14113
xorl %ebp, %ebp
movq %r14, %rdx
xorl %eax, %eax
callq 0x45f0
jmp 0x8f07
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rsi, %r14
cmpl $0x3, %edx
jne 0x938e
movq 0x280(%r14), %rbx
movq 0x8(%r15), %rsi
leaq 0x4(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
callq 0x4540
testl %eax, %eax
jne 0x93ac
xorl %r12d, %r12d
pushq $-0x1
popq %rbp
movslq 0x4(%rsp), %rax
cmpq %rax, %r12
jge 0x93c3
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %rdi
movq 0x10(%r15), %rsi
callq 0x4480
testl %eax, %eax
jne 0x93c0
incq %r12
jmp 0x9369
movq (%r15), %rdx
leaq 0xa4c8(%rip), %rsi      # 0x13860
leaq 0xac36(%rip), %rcx      # 0x13fd5
movq %r14, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %r14
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r12d, %ebp
movq (%r14), %rdi
leaq 0x9f46(%rip), %rsi      # 0x13313
xorl %r14d, %r14d
movl %ebp, %edx
xorl %eax, %eax
callq 0x45f0
movq 0x8(%rsp), %rsi
leaq 0xab06(%rip), %rdx      # 0x13eeb
movq %rbx, %rdi
movl $0x45e, %ecx            # imm = 0x45E
callq 0x4280
jmp 0x93b0
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxCmdIL.c
// Function: Hax_LsortCmd
int
Hax_LsortCmd(
    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;

    if (argc != 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" list\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (Hax_SplitList(interp, argv[1], &listArgc, &listArgv) != HAX_OK) {
	return HAX_ERROR;
    }
    qsort(listArgv, listArgc, sizeof (char *), SortCompareProc);
    interp->result = Hax_Merge(interp, listArgc, listArgv);
    interp->freeProc = (Hax_FreeProc *) free;
    ckfree(memoryp, (char *) listArgv);
    return HAX_OK;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
cmpl $0x2, %edx
jne 0x9479
movq 0x280(%rbx), %r14
movq 0x8(%rcx), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x4540
testl %eax, %eax
jne 0x9497
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
leaq 0x6d(%rip), %rcx        # 0x94a2
pushq $0x8
popq %rdx
callq 0x4130
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x4530
movq %rax, (%rbx)
movq 0x11b48(%rip), %rax     # 0x1afa0
movq %rax, 0x8(%rbx)
movq 0x10(%rsp), %rsi
leaq 0xaa83(%rip), %rdx      # 0x13eeb
movq %r14, %rdi
movl $0x48b, %ecx            # imm = 0x48B
callq 0x4280
xorl %eax, %eax
jmp 0x949a
movq (%rcx), %rdx
leaq 0xa3dd(%rip), %rsi      # 0x13860
leaq 0xaa9c(%rip), %rcx      # 0x13f26
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxCmdMZ.c
// Function: Hax_RenameCmd
int
Hax_RenameCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    Command *cmdPtr;
    Interp *iPtr = (Interp *) interp;
    Hax_HashEntry *hPtr;
    int newPtr;

    if (argc != 3) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" oldName newName\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (argv[2][0] == '\0') {
	if (Hax_DeleteCommand(interp, argv[1]) != 0) {
	    Hax_AppendResult(interp, "can't delete \"", argv[1],
		    "\": command doesn't exist", (char *) NULL);
	    return HAX_ERROR;
	}
	return HAX_OK;
    }
    hPtr = Hax_FindHashEntry(&iPtr->commandTable, argv[2]);
    if (hPtr != NULL) {
	Hax_AppendResult(interp, "can't rename to \"", argv[2],
		"\": command already exists", (char *) NULL);
	return HAX_ERROR;
    }
    hPtr = Hax_FindHashEntry(&iPtr->commandTable, argv[1]);
    if (hPtr == NULL) {
	Hax_AppendResult(interp, "can't rename \"", argv[1],
		"\":  command doesn't exist", (char *) NULL);
	return HAX_ERROR;
    }
    cmdPtr = (Command *) Hax_GetHashValue(hPtr);
    Hax_DeleteHashEntry(interp, hPtr);
    hPtr = Hax_CreateHashEntry(interp, &iPtr->commandTable, argv[2], &newPtr);
    Hax_SetHashValue(hPtr, cmdPtr);
    return HAX_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x3, %edx
jne 0x9c00
movq 0x10(%r14), %rsi
cmpb $0x0, (%rsi)
je 0x9c2d
leaq 0x18(%rbx), %r15
movq %r15, %rdi
callq *0x58(%rbx)
testq %rax, %rax
je 0x9c51
movq 0x10(%r14), %rdx
leaq 0xa5a5(%rip), %rsi      # 0x1419c
leaq 0xa5b0(%rip), %rcx      # 0x141ae
jmp 0x9c11
movq (%r14), %rdx
leaq 0x9c56(%rip), %rsi      # 0x13860
leaq 0xa551(%rip), %rcx      # 0x14162
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x4320
testl %eax, %eax
je 0x9c85
movq 0x8(%r14), %rdx
leaq 0xa52c(%rip), %rsi      # 0x14174
leaq 0xa534(%rip), %rcx      # 0x14183
jmp 0x9c11
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq *0x58(%rbx)
testq %rax, %rax
je 0x9c89
movq 0x18(%rax), %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x42f0
movq 0x10(%r14), %rdx
leaq 0x4(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x60(%rbx)
movq %r12, 0x18(%rax)
xorl %eax, %eax
jmp 0x9c21
movq 0x8(%r14), %rdx
leaq 0xa534(%rip), %rsi      # 0x141c8
leaq 0xa53c(%rip), %rcx      # 0x141d7
jmp 0x9c11
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxCmdMZ.c
// Function: Hax_ReturnCmd
int
Hax_ReturnCmd(
    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],
		" ?value?\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (argc == 2) {
	Hax_SetResult(interp, argv[1], HAX_VOLATILE);
    }
    return HAX_RETURN;
}

// Assembly:
pushq %rbx
cmpl $0x3, %edx
jl 0x9ccc
movq (%rcx), %rdx
leaq 0x9bb0(%rip), %rax      # 0x13860
leaq 0xa53a(%rip), %rcx      # 0x141f1
movq %rsi, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rbx
jmp 0x9ce6
pushq $0x2
popq %rbx
cmpl $0x2, %edx
jne 0x9ce6
movq 0x8(%rcx), %rax
pushq $-0x1
popq %rdx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4500
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxCmdMZ.c
// Function: Hax_SplitCmd
int
Hax_SplitCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    char *splitChars;
    char *p, *p2;
    char *elementStart;

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

    /*
     * Handle the special case of splitting on every character.
     */

    if (*splitChars == 0) {
	char string[2];
	string[1] = 0;
	for (p = argv[1]; *p != 0; p++) {
	    string[0] = *p;
	    Hax_AppendElement(interp, string, 0);
	}
	return HAX_OK;
    }

    /*
     * Normal case: split on any of a given set of characters.
     * Discard instances of the split characters.
     */

    for (p = elementStart = argv[1]; *p != 0; p++) {
	char c = *p;
	for (p2 = splitChars; *p2 != 0; p2++) {
	    if (*p2 == c) {
		*p = 0;
		Hax_AppendElement(interp, elementStart, 0);
		*p = c;
		elementStart = p+1;
		break;
	    }
	}
    }
    if (p != argv[1]) {
	Hax_AppendElement(interp, elementStart, 0);
    }
    return HAX_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x2, %edx
je 0xa12a
cmpl $0x3, %edx
jne 0xa189
movq 0x10(%r14), %r15
jmp 0xa131
leaq 0xa199(%rip), %r15      # 0x142ca
cmpb $0x0, (%r15)
je 0xa1ac
movq 0x8(%r14), %r12
movq %r12, %rsi
movb (%r12), %bpl
testb %bpl, %bpl
je 0xa175
movq %r15, %rax
movb (%rax), %cl
testb %cl, %cl
je 0xa170
incq %rax
cmpb %bpl, %cl
jne 0xa14a
movb $0x0, (%r12)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4050
movb %bpl, (%r12)
leaq 0x1(%r12), %rsi
incq %r12
jmp 0xa13e
cmpq 0x8(%r14), %r12
je 0xa1d7
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4050
jmp 0xa1d9
movq (%r14), %rdx
leaq 0x96cd(%rip), %rsi      # 0x13860
leaq 0xa135(%rip), %rcx      # 0x142cf
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rbp
jmp 0xa1d9
leaq 0xe(%rsp), %r15
movb $0x0, 0x1(%r15)
movq 0x8(%r14), %r14
movb (%r14), %al
testb %al, %al
je 0xa1d7
movb %al, 0xe(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4050
incq %r14
jmp 0xa1ba
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxCmdMZ.c
// Function: Hax_WhileCmd
int
Hax_WhileCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    int result, value;

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

    while (1) {
	result = Hax_ExprBoolean(interp, argv[1], &value);
	if (result != HAX_OK) {
	    return result;
	}
	if (!value) {
	    break;
	}
	result = Hax_Eval(interp, NULL, argv[2], 0, (char **) NULL);
	if (result == HAX_CONTINUE) {
	    result = HAX_OK;
	} else if (result != HAX_OK) {
	    if (result == HAX_ERROR) {
		char msg[60];
		sprintf(msg, "\n    (\"while\" body line %d)",
			interp->errorLine);
		Hax_AddErrorInfo(interp, msg);
	    }
	    break;
	}
    }
    if (result == HAX_BREAK) {
	result = HAX_OK;
    }
    if (result == HAX_OK) {
	Hax_ResetResult(interp);
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x3, %edx
jne 0xb02b
leaq 0xc(%rsp), %r15
leaq 0x9094(%rip), %r12      # 0x1405c
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4670
testl %eax, %eax
jne 0xb058
cmpl $0x0, 0xc(%rsp)
je 0xb04e
movq 0x10(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45d0
cmpl $0x4, %eax
ja 0xb058
movl %eax, %ecx
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
movl 0x10(%rbx), %edx
leaq 0x9558(%rip), %rsi      # 0x14567
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x45f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4420
jmp 0xb049
movq (%r14), %rdx
leaq 0x882b(%rip), %rsi      # 0x13860
leaq 0x951c(%rip), %rcx      # 0x14558
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rax
jmp 0xb058
movq %rbx, %rdi
callq 0x42d0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxExpr.c
// Function: Hax_ExprLong
int
Hax_ExprLong(
    Hax_Interp *interp,			/* Context in which to evaluate the
					 * expression. */
    char *string,			/* Expression to evaluate. */
    long *ptr				/* Where to store result. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Value value;
    int result;

    result = ExprTopLevel(interp, string, &value);
    if (result == HAX_OK) {
	if (value.type == TYPE_LLONG) {
	    *ptr = value.llongValue;
	} else if (value.type == TYPE_DOUBLE) {
	    *ptr = value.doubleValue;
	} else {
	    interp->result = (char *) "expression didn't have numeric value";
	    result = HAX_ERROR;
	}
    }
    if (value.pv.buffer != value.staticSpace) {
	ckfree(memoryp, value.pv.buffer);
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rdi, %r15
movq 0x280(%rdi), %rbx
movq %rsp, %rdx
callq 0xb0ef
movl %eax, %ebp
testl %eax, %eax
jne 0xb0bd
movl 0xd0(%rsp), %eax
cmpl $0x1, %eax
je 0xb0a2
testl %eax, %eax
jne 0xb0b0
movq (%rsp), %rax
jmp 0xb0a9
cvttsd2si 0x8(%rsp), %rax
movq %rax, (%r14)
xorl %ebp, %ebp
jmp 0xb0bd
leaq 0x9709(%rip), %rax      # 0x147c0
movq %rax, (%r15)
pushq $0x1
popq %rbp
leaq 0x38(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xb0df
leaq 0x9713(%rip), %rdx      # 0x147e5
movq %rbx, %rdi
movl $0x4cd, %ecx            # imm = 0x4CD
callq 0x4280
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxExpr.c
// Function: ExprTopLevel
static int
ExprTopLevel(
    Hax_Interp *interp,			/* Context in which to evaluate the
					 * expression. */
    char *string,			/* Expression to evaluate. */
    Value *valuePtr			/* Where to store result.  Should
					 * not be initialized by caller. */)
{
    ExprInfo info;
    int result;

    info.originalExpr = string;
    info.expr = string;
    valuePtr->pv.buffer = valuePtr->pv.next = valuePtr->staticSpace;
    valuePtr->pv.end = valuePtr->pv.buffer + STATIC_STRING_SPACE - 1;
    valuePtr->pv.expandProc = HaxExpandParseValue;
    valuePtr->pv.clientData = (ClientData) NULL;

    result = ExprGetValue(interp, &info, -1, valuePtr);
    if (result != HAX_OK) {
	return result;
    }
    if (info.token != END) {
	Hax_AppendResult(interp, "syntax error in expression \"",
		string, "\"", (char *) NULL);
	return HAX_ERROR;
    }
    return HAX_OK;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rsi
movq %rbx, (%rsi)
movq %rbx, 0x8(%rsi)
leaq 0x38(%rdx), %rax
movq %rax, 0x18(%rdx)
movq %rax, 0x10(%rdx)
leaq 0xcd(%rdx), %rax
movq %rax, 0x20(%rdx)
movq 0xfeb1(%rip), %rax      # 0x1afd8
movq %rax, 0x28(%rdx)
andq $0x0, 0x30(%rdx)
pushq $-0x1
popq %rdx
callq 0xb3f3
testl %eax, %eax
jne 0xb166
xorl %eax, %eax
cmpl $0x3, 0x10(%rsp)
je 0xb166
leaq 0x96a3(%rip), %rsi      # 0x147ef
leaq 0x815c(%rip), %rcx      # 0x132af
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxExpr.c
// Function: Hax_ExprLongLong
int
Hax_ExprLongLong(
    Hax_Interp *interp,			/* Context in which to evaluate the
					 * expression. */
    char *string,			/* Expression to evaluate. */
    long long int *ptr			/* Where to store result. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Value value;
    int result;

    result = ExprTopLevel(interp, string, &value);
    if (result == HAX_OK) {
	if (value.type == TYPE_LLONG) {
	    *ptr = value.llongValue;
	} else if (value.type == TYPE_DOUBLE) {
	    *ptr = value.doubleValue;
	} else {
	    interp->result = (char *) "expression didn't have numeric value";
	    result = HAX_ERROR;
	}
    }
    if (value.pv.buffer != value.staticSpace) {
	ckfree(memoryp, value.pv.buffer);
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rdi, %r15
movq 0x280(%rdi), %rbx
movq %rsp, %rdx
callq 0xb0ef
movl %eax, %ebp
testl %eax, %eax
jne 0xb1c7
movl 0xd0(%rsp), %eax
cmpl $0x1, %eax
je 0xb1ac
testl %eax, %eax
jne 0xb1ba
movq (%rsp), %rax
jmp 0xb1b3
cvttsd2si 0x8(%rsp), %rax
movq %rax, (%r14)
xorl %ebp, %ebp
jmp 0xb1c7
leaq 0x95ff(%rip), %rax      # 0x147c0
movq %rax, (%r15)
pushq $0x1
popq %rbp
leaq 0x38(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xb1e9
leaq 0x9609(%rip), %rdx      # 0x147e5
movq %rbx, %rdi
movl $0x4ea, %ecx            # imm = 0x4EA
callq 0x4280
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxExpr.c
// Function: Hax_ExprBoolean
int
Hax_ExprBoolean(
    Hax_Interp *interp,			/* Context in which to evaluate the
					 * expression. */
    char *string,			/* Expression to evaluate. */
    int *ptr				/* Where to store 0/1 result. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Value value;
    int result;

    result = ExprTopLevel(interp, string, &value);
    if (result == HAX_OK) {
	if (value.type == TYPE_LLONG) {
	    *ptr = value.llongValue != 0;
	} else if (value.type == TYPE_DOUBLE) {
	    *ptr = value.doubleValue != 0.0;
	} else {
	    interp->result = (char *) "expression didn't have numeric value";
	    result = HAX_ERROR;
	}
    }
    if (value.pv.buffer != value.staticSpace) {
	ckfree(memoryp, value.pv.buffer);
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rdi, %r15
movq 0x280(%rdi), %rbx
movq %rsp, %rdx
callq 0xb0ef
movl %eax, %ebp
testl %eax, %eax
jne 0xb2f5
movl 0xd0(%rsp), %eax
cmpl $0x1, %eax
je 0xb2ce
testl %eax, %eax
jne 0xb2e8
xorl %eax, %eax
cmpq $0x0, (%rsp)
setne %al
movl %eax, (%r14)
jmp 0xb2e4
xorpd %xmm0, %xmm0
cmpneqsd 0x8(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movl %eax, (%r14)
xorl %ebp, %ebp
jmp 0xb2f5
leaq 0x94d1(%rip), %rax      # 0x147c0
movq %rax, (%r15)
pushq $0x1
popq %rbp
leaq 0x38(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xb317
leaq 0x94db(%rip), %rdx      # 0x147e5
movq %rbx, %rdi
movl $0x524, %ecx            # imm = 0x524
callq 0x4280
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxExpr.c
// Function: Hax_ExprString
int
Hax_ExprString(
    Hax_Interp *interp,			/* Context in which to evaluate the
					 * expression. */
    char *string			/* Expression to evaluate. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Value value;
    int result;

    result = ExprTopLevel(interp, string, &value);
    if (result == HAX_OK) {
	if (value.type == TYPE_LLONG) {
	    sprintf(interp->result, "%lld", value.llongValue);
	} else if (value.type == TYPE_DOUBLE) {
	    sprintf(interp->result, "%g", value.doubleValue);
	} else {
	    if (value.pv.buffer != value.staticSpace) {
		interp->result = value.pv.buffer;
		interp->freeProc = (Hax_FreeProc *) free;
		value.pv.buffer = value.staticSpace;
	    } else {
		Hax_SetResult(interp, value.pv.buffer, HAX_VOLATILE);
	    }
	}
    }
    if (value.pv.buffer != value.staticSpace) {
	ckfree(memoryp, value.pv.buffer);
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %r14
movq 0x280(%rdi), %rbx
leaq 0x8(%rsp), %rdx
callq 0xb0ef
movl %eax, %ebp
testl %eax, %eax
je 0xb37c
leaq 0x40(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xb36e
leaq 0x9484(%rip), %rdx      # 0x147e5
movq %rbx, %rdi
movl $0x558, %ecx            # imm = 0x558
callq 0x4280
movl %ebp, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl 0xd8(%rsp), %eax
cmpl $0x1, %eax
je 0xb3a4
testl %eax, %eax
jne 0xb3bd
movq (%r14), %rdi
movq 0x8(%rsp), %rdx
leaq 0x8879(%rip), %rsi      # 0x13c14
xorl %eax, %eax
callq 0x45f0
jmp 0xb34c
movq (%r14), %rdi
movsd 0x10(%rsp), %xmm0
leaq 0x8f13(%rip), %rsi      # 0x142c7
movb $0x1, %al
callq 0x45f0
jmp 0xb34c
leaq 0x40(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xb3e3
movq %rsi, (%r14)
movq 0xfbcb(%rip), %rcx      # 0x1afa0
movq %rcx, 0x8(%r14)
movq %rax, 0x18(%rsp)
jmp 0xb34c
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x4500
jmp 0xb34c
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxExpr.c
// Function: ExprMakeString
static void
ExprMakeString(
    Hax_Interp *interp,
    Value *valuePtr		/* Value to be converted. */)
{
    int shortfall;

    shortfall = 150 - (valuePtr->pv.end - valuePtr->pv.buffer);
    if (shortfall > 0) {
	(*valuePtr->pv.expandProc)(interp, &valuePtr->pv, shortfall);
    }
    if (valuePtr->type == TYPE_LLONG) {
	sprintf(valuePtr->pv.buffer, "%lld", valuePtr->llongValue);
    } else if (valuePtr->type == TYPE_DOUBLE) {
	sprintf(valuePtr->pv.buffer, "%g", valuePtr->doubleValue);
    }
    valuePtr->type = TYPE_STRING;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl 0x10(%rsi), %edx
subl 0x20(%rsi), %edx
addl $0x96, %edx
testl %edx, %edx
jle 0xc1f2
leaq 0x10(%rbx), %rsi
callq *0x28(%rbx)
movl 0xd0(%rbx), %eax
cmpl $0x1, %eax
je 0xc218
testl %eax, %eax
jne 0xc22f
movq (%rbx), %rdx
movq 0x10(%rbx), %rdi
leaq 0x7a05(%rip), %rsi      # 0x13c14
xorl %eax, %eax
callq 0x45f0
jmp 0xc22f
movq 0x10(%rbx), %rdi
movsd 0x8(%rbx), %xmm0
leaq 0x809f(%rip), %rsi      # 0x142c7
movb $0x1, %al
callq 0x45f0
movl $0x2, 0xd0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxGet.c
// Function: Hax_GetInt
int
Hax_GetInt(
    Hax_Interp *interp,		/* Interpreter to use for error reporting. */
    char *string,		/* String containing a (possibly signed)
				 * integer in a form acceptable to strtol. */
    int *intPtr			/* Place to store converted result. */)
{
    char *end;
    int i;

    i = Strtol(NULL, string, &end, 0);
    while ((*end != '\0') && isspace(*end)) {
	end++;
    }
    if ((end == string) || (*end != 0)) {
	Hax_AppendResult(interp, "expected integer but got \"", string,
		"\"", (char *) NULL);
	return HAX_ERROR;
    }
    *intPtr = i;
    return HAX_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r13
xorl %edi, %edi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x43e0
movq %rax, %r12
movq (%r13), %r13
movsbq (%r13), %rbp
testq %rbp, %rbp
je 0xc414
callq 0x4660
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbp,2)
je 0xc420
incq %r13
movq %r13, (%rsp)
jmp 0xc3f2
cmpq %rbx, %r13
je 0xc420
movl %r12d, (%r15)
xorl %eax, %eax
jmp 0xc441
leaq 0x8533(%rip), %rsi      # 0x1495a
leaq 0x6e81(%rip), %rcx      # 0x132af
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxGet.c
// Function: Hax_GetLong
int
Hax_GetLong(
    Hax_Interp *interp,		/* Interpreter to use for error reporting. */
    char *string,		/* String containing a (possibly signed)
				 * integer in a form acceptable to strtol. */
    long int *longPtr		/* Place to store converted result. */)
{
    char *end;
    long int i;

    i = Strtol(NULL, string, &end, 0);
    while ((*end != '\0') && isspace(*end)) {
	end++;
    }
    if ((end == string) || (*end != 0)) {
	Hax_AppendResult(interp, "expected integer but got \"", string,
		"\"", (char *) NULL);
	return HAX_ERROR;
    }
    *longPtr = i;
    return HAX_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r13
xorl %edi, %edi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x43e0
movq %rax, %r12
movq (%r13), %r13
movsbq (%r13), %rbp
testq %rbp, %rbp
je 0xc49c
callq 0x4660
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbp,2)
je 0xc4a8
incq %r13
movq %r13, (%rsp)
jmp 0xc47a
cmpq %rbx, %r13
je 0xc4a8
movq %r12, (%r15)
xorl %eax, %eax
jmp 0xc4c9
leaq 0x84ab(%rip), %rsi      # 0x1495a
leaq 0x6df9(%rip), %rcx      # 0x132af
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq