LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x7bff
movq (%r14), %rdx
leaq 0xdc8b(%rip), %rsi      # 0x15874
leaq 0xdd57(%rip), %rcx      # 0x15947
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
jmp 0x7c58
cmpl $0x3, %r15d
jl 0x7c1d
movq 0x10(%r14), %rsi
cmpb $0x0, (%rsi)
je 0x7c1d
movq %rbx, %rdi
callq 0x4400
orb $0x4, 0x1a0(%rbx)
cmpl $0x4, %r15d
jne 0x7c45
movq 0x18(%r14), %rcx
leaq 0xd737(%rip), %rsi      # 0x15365
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1, %r8d
callq 0x40e0
orb $0x8, 0x1a0(%rbx)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x44e0
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7c9d
movq (%rcx), %rdx
leaq 0xdbf5(%rip), %rsi      # 0x15874
leaq 0xe886(%rip), %rcx      # 0x1650c
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %ebp
jmp 0x7d28
cmpl $0x2, %edx
jne 0x7cb9
movq 0x8(%rcx), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45b0
movl %eax, %ebp
jmp 0x7d01
movq 0x280(%rbx), %r14
decl %edx
addq $0x8, %rcx
movq %rbx, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x4660
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45b0
movl %eax, %ebp
leaq 0xdbf3(%rip), %rdx      # 0x158e4
movq %r14, %rdi
movq %r15, %rsi
movl $0x196, %ecx            # imm = 0x196
callq 0x4280
cmpl $0x1, %ebp
jne 0x7d28
movl 0x10(%rbx), %edx
leaq 0xdc59(%rip), %rsi      # 0x15969
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x45d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4400
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x5, %edx
jne 0x7e22
movq 0x8(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45b0
movl %eax, %ebp
cmpl $0x1, %eax
je 0x7e47
testl %ebp, %ebp
jne 0x7ea1
leaq 0xc(%rsp), %r15
xorl %r12d, %r12d
movq 0x10(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4650
testl %eax, %eax
jne 0x7e58
cmpl $0x0, 0xc(%rsp)
je 0x7e5c
movq 0x20(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45b0
testl %eax, %eax
je 0x7df2
movl %eax, %ebp
cmpl $0x4, %eax
jne 0x7e60
movq 0x18(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45b0
testl %eax, %eax
je 0x7db2
movl %eax, %ebp
cmpl $0x3, %eax
je 0x7e8e
cmpl $0x1, %ebp
jne 0x7ea1
leaq 0xdbc2(%rip), %rsi      # 0x159e2
jmp 0x7e4e
movq (%r14), %rdx
leaq 0xda48(%rip), %rsi      # 0x15874
leaq 0xdb5e(%rip), %rcx      # 0x15991
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %ebp
jmp 0x7ea1
leaq 0xdb5d(%rip), %rsi      # 0x159ab
movq %rbx, %rdi
callq 0x4400
jmp 0x7ea1
movl %eax, %ebp
jmp 0x7ea1
xorl %ebp, %ebp
jmp 0x7e8e
cmpl $0x1, %ebp
jne 0x7e8e
movl 0x10(%rbx), %edx
leaq 0xdb59(%rip), %rsi      # 0x159c8
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x45d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4400
movl $0x1, %ebp
cmpl $0x3, %ebp
cmovel %r12d, %ebp
testl %ebp, %ebp
jne 0x7ea1
movq %rbx, %rdi
callq 0x42d0
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8875
movq (%r14), %rdx
leaq 0xd01d(%rip), %rsi      # 0x15874
leaq 0xd4fd(%rip), %rcx      # 0x15d5b
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %ebp
jmp 0x8937
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movl $0x200, %edx            # imm = 0x200
callq 0x4550
movl $0x1, %ebp
testq %rax, %rax
je 0x8937
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x45f0
testl %eax, %eax
je 0x88b9
leaq 0xd4c2(%rip), %rsi      # 0x15d71
movq %rbx, %rdi
callq 0x4400
jmp 0x8937
cmpl $0x2, %r15d
jne 0x88c6
incq 0x8(%rsp)
jmp 0x88fe
movq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x45f0
movl %eax, %r15d
testl %eax, %eax
je 0x88ef
leaq 0xd4ba(%rip), %rsi      # 0x15d9f
movq %rbx, %rdi
callq 0x4400
jmp 0x88f9
movq 0x10(%rsp), %rax
addq %rax, 0x8(%rsp)
testl %r15d, %r15d
jne 0x8937
movq 0x8(%rsp), %rdx
leaq 0xd4ae(%rip), %rsi      # 0x15db8
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x45d0
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movl $0x200, %ecx            # imm = 0x200
callq 0x4450
testq %rax, %rax
je 0x8937
movq %rax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9537
cmpl $0x3, %edx
jne 0x95c5
movq 0x10(%rcx), %r15
jmp 0x953e
leaq 0xd9f2(%rip), %r15      # 0x16f30
movq 0x8(%rcx), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x4520
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x95e8
cmpl $0x0, 0xc(%rsp)
jle 0x95a8
xorl %r12d, %r12d
movq 0x10(%rsp), %rax
testq %r12, %r12
je 0x958c
movq (%rax,%r12,8), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x4500
jmp 0x959b
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x4500
incq %r12
movslq 0xc(%rsp), %rax
cmpq %rax, %r12
jl 0x956d
movq 0x10(%rsp), %rsi
leaq 0xcadb(%rip), %rdx      # 0x1608f
movq %r14, %rdi
movl $0x26c, %ecx            # imm = 0x26C
callq 0x4280
xorl %eax, %eax
jmp 0x95e8
movq (%rcx), %rdx
leaq 0xc2a5(%rip), %rsi      # 0x15874
leaq 0xcaa5(%rip), %rcx      # 0x1607b
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r12
movq %rsi, %r14
cmpl $0x3, %edx
jne 0x9704
movq 0x280(%r14), %r15
movq 0x10(%r12), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x44b0
movl $0x1, %ebx
testl %eax, %eax
jne 0x9728
xorl %ebx, %ebx
cmpq $0x0, 0x10(%rsp)
js 0x9728
movq %r15, 0x30(%rsp)
movq 0x8(%r12), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x10(%rsp)
js 0x96a4
leaq 0x20(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x1c(%rsp), %r15
movq 0x28(%rsp), %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
movq %r15, %r9
callq 0x4360
testl %eax, %eax
jne 0x9739
movq 0x10(%rsp), %rax
leaq -0x1(%rax), %rcx
movq %rcx, 0x10(%rsp)
testq %rax, %rax
jg 0x9670
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x9728
cmpq $0xc7, %rsi
jl 0x96dd
incl %esi
leaq 0xc9cf(%rip), %rdx      # 0x1608f
movq 0x30(%rsp), %rdi
movl $0x2a5, %ecx            # imm = 0x2A5
callq 0x44c0
movq %rax, (%r14)
movq 0x128c7(%rip), %rax     # 0x1bfa0
movq %rax, 0x8(%r14)
cmpl $0x0, 0x1c(%rsp)
je 0x973d
movq (%r14), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x43a0
movq (%r14), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x9728
movq (%r12), %rdx
leaq 0xc165(%rip), %rsi      # 0x15874
leaq 0xc984(%rip), %rcx      # 0x1609a
movq %r14, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
jmp 0x9728
movl 0x8(%rsp), %edi
movq 0x20(%rsp), %rsi
movq (%r14), %rdx
callq 0x4160
jmp 0x9728
// File: /workspace/github_c_makefile_star2_O1/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 0x9911
movq (%rcx), %rdx
leaq 0xbf7e(%rip), %rsi      # 0x15874
leaq 0xcc0f(%rip), %rcx      # 0x1650c
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
jmp 0x9934
decl %edx
addq $0x8, %rcx
movq %rbx, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x4510
movq %rax, (%rbx)
movq 0x12672(%rip), %rax     # 0x1bfa0
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
cmpl $0x2, %edx
jne 0x9995
movq 0x8(%rcx), %rsi
movq %rsi, (%rsp)
xorl %ebx, %ebx
cmpb $0x0, (%rsi)
je 0x99ba
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq %rsp, %r13
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4360
testl %eax, %eax
jne 0x99d3
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x99bd
incq %r15
movq (%rsp), %rsi
cmpb $0x0, (%rsi)
jne 0x9965
jmp 0x99bd
movq (%rcx), %rdx
leaq 0xbed5(%rip), %rsi      # 0x15874
leaq 0xc724(%rip), %rcx      # 0x160ca
movq %r14, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %ebx
jmp 0x99d5
xorl %r15d, %r15d
movq (%r14), %rdi
leaq 0xc96c(%rip), %rsi      # 0x16333
movq %r15, %rdx
xorl %eax, %eax
callq 0x45d0
jmp 0x99d5
movl %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9ec1
movq 0x280(%r14), %rbx
movq 0x8(%r15), %rsi
leaq 0x4(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
callq 0x4520
movl $0x1, %r12d
testl %eax, %eax
jne 0x9f19
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x0, 0x4(%rsp)
jle 0x9eea
xorl %r12d, %r12d
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %rdi
movq 0x10(%r15), %rsi
callq 0x4460
testl %eax, %eax
jne 0x9ee7
incq %r12
movslq 0x4(%rsp), %rax
cmpq %rax, %r12
jl 0x9e9c
jmp 0x9eea
movq (%r15), %rdx
leaq 0xb9a9(%rip), %rsi      # 0x15874
leaq 0xc2a7(%rip), %rcx      # 0x16179
movq %r14, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %r12d
jmp 0x9f19
movl %r12d, %ebp
movq (%r14), %rdi
leaq 0xb41f(%rip), %rsi      # 0x15313
xorl %r12d, %r12d
movl %ebp, %edx
xorl %eax, %eax
callq 0x45d0
movq 0x8(%rsp), %rsi
leaq 0xc183(%rip), %rdx      # 0x1608f
movq %rbx, %rdi
movl $0x45e, %ecx            # imm = 0x45E
callq 0x4280
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9fb7
movq 0x280(%rbx), %r14
movq 0x8(%rcx), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x4520
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x9fda
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
leaq 0x71(%rip), %rcx        # 0x9fe2
movl $0x8, %edx
callq 0x4130
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x4510
movq %rax, (%rbx)
movq 0x1200a(%rip), %rax     # 0x1bfa0
movq %rax, 0x8(%rbx)
movq 0x10(%rsp), %rsi
leaq 0xc0e9(%rip), %rdx      # 0x1608f
movq %r14, %rdi
movl $0x48b, %ecx            # imm = 0x48B
callq 0x4280
xorl %eax, %eax
jmp 0x9fda
movq (%rcx), %rdx
leaq 0xb8b3(%rip), %rsi      # 0x15874
leaq 0xc102(%rip), %rcx      # 0x160ca
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa835
movq 0x10(%r14), %rsi
cmpb $0x0, (%rsi)
je 0xa864
leaq 0x18(%rbx), %r15
movq %r15, %rdi
callq *0x58(%rbx)
testq %rax, %rax
je 0xa888
movq 0x10(%r14), %rdx
leaq 0xbb90(%rip), %rsi      # 0x163bc
leaq 0xbb9b(%rip), %rcx      # 0x163ce
jmp 0xa846
movq (%r14), %rdx
leaq 0xb035(%rip), %rsi      # 0x15874
leaq 0xbb3c(%rip), %rcx      # 0x16382
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x4300
testl %eax, %eax
je 0xa8bc
movq 0x8(%r14), %rdx
leaq 0xbb15(%rip), %rsi      # 0x16394
leaq 0xbb1d(%rip), %rcx      # 0x163a3
jmp 0xa846
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq *0x58(%rbx)
testq %rax, %rax
je 0xa8c0
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 0xa858
movq 0x8(%r14), %rdx
leaq 0xbb1d(%rip), %rsi      # 0x163e8
leaq 0xbb25(%rip), %rcx      # 0x163f7
jmp 0xa846
// File: /workspace/github_c_makefile_star2_O1/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 0xa905
movq (%rcx), %rdx
leaq 0xaf8d(%rip), %rax      # 0x15874
leaq 0xbb23(%rip), %rcx      # 0x16411
movq %rsi, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %ebx
jmp 0xa925
movl $0x2, %ebx
cmpl $0x2, %edx
jne 0xa925
movq 0x8(%rcx), %rax
movq %rsi, %rdi
movq %rax, %rsi
movq $-0x1, %rdx
callq 0x44e0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x2, %edx
je 0xada3
cmpl $0x3, %edx
jne 0xae04
movq 0x10(%r14), %r15
jmp 0xadaa
leaq 0xb740(%rip), %r15      # 0x164ea
cmpb $0x0, (%r15)
je 0xae29
movq 0x8(%r14), %rsi
movb (%rsi), %bpl
testb %bpl, %bpl
je 0xae5e
leaq 0x1(%r15), %r13
movq %rsi, %r12
movb (%r15), %cl
movq %r13, %rax
testb %cl, %cl
je 0xadf5
cmpb %bpl, %cl
je 0xaddd
movb (%rax), %cl
incq %rax
jmp 0xadcd
movb $0x0, (%r12)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4050
movb %bpl, (%r12)
leaq 0x1(%r12), %rsi
movb 0x1(%r12), %bpl
incq %r12
testb %bpl, %bpl
jne 0xadc7
jmp 0xae61
movq (%r14), %rdx
leaq 0xaa66(%rip), %rsi      # 0x15874
leaq 0xb6da(%rip), %rcx      # 0x164ef
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %ebp
jmp 0xae77
movb $0x0, 0x7(%rsp)
movq 0x8(%r14), %r15
movb (%r15), %al
testb %al, %al
je 0xae75
incq %r15
leaq 0x6(%rsp), %r14
movb %al, 0x6(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4050
movb (%r15), %al
incq %r15
testb %al, %al
jne 0xae41
jmp 0xae75
movq %rsi, %r12
cmpq 0x8(%r14), %r12
je 0xae75
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4050
jmp 0xae77
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x3, %edx
jne 0xbe5e
movq 0x8(%r14), %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x4650
testl %eax, %eax
je 0xbe90
movl %eax, %ebp
jmp 0xbe81
movq (%r14), %rdx
leaq 0x9a0c(%rip), %rsi      # 0x15874
leaq 0xa909(%rip), %rcx      # 0x16778
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %ebp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
cmpl $0x0, 0xc(%rsp)
je 0xbf02
movq 0x10(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45b0
testl %eax, %eax
je 0xbebb
cmpl $0x4, %eax
jne 0xbed0
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4650
testl %eax, %eax
je 0xbe98
jmp 0xbe5a
movl %eax, %r12d
cmpl $0x1, %eax
jne 0xbf02
movl 0x10(%rbx), %edx
leaq 0xa8a5(%rip), %rsi      # 0x16787
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x45d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4400
movl $0x1, %r12d
xorl %ebp, %ebp
cmpl $0x3, %r12d
cmovnel %r12d, %ebp
testl %ebp, %ebp
jne 0xbe81
movq %rbx, %rdi
callq 0x42d0
jmp 0xbe81
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xbfb1
movl %eax, %ebp
testl %eax, %eax
jne 0xbf7f
movl 0xd0(%rsp), %eax
cmpl $0x1, %eax
je 0xbf62
testl %eax, %eax
jne 0xbf70
movq (%rsp), %rax
jmp 0xbf69
cvttsd2si 0x8(%rsp), %rax
movq %rax, (%r14)
xorl %ebp, %ebp
jmp 0xbf7f
leaq 0xaa69(%rip), %rax      # 0x169e0
movq %rax, (%r15)
movl $0x1, %ebp
leaq 0x38(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xbfa1
leaq 0xaa71(%rip), %rdx      # 0x16a05
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_O1/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 0xffef(%rip), %rax      # 0x1bfd8
movq %rax, 0x28(%rdx)
movq $0x0, 0x30(%rdx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xc2c6
testl %eax, %eax
jne 0xc02f
xorl %eax, %eax
cmpl $0x3, 0x10(%rsp)
je 0xc02f
leaq 0xa9fc(%rip), %rsi      # 0x16a0f
leaq 0x9295(%rip), %rcx      # 0x152af
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbfb1
movl %eax, %ebp
testl %eax, %eax
jne 0xc092
movl 0xd0(%rsp), %eax
cmpl $0x1, %eax
je 0xc075
testl %eax, %eax
jne 0xc083
movq (%rsp), %rax
jmp 0xc07c
cvttsd2si 0x8(%rsp), %rax
movq %rax, (%r14)
xorl %ebp, %ebp
jmp 0xc092
leaq 0xa956(%rip), %rax      # 0x169e0
movq %rax, (%r15)
movl $0x1, %ebp
leaq 0x38(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xc0b4
leaq 0xa95e(%rip), %rdx      # 0x16a05
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_O1/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 0xbfb1
movl %eax, %ebp
testl %eax, %eax
jne 0xc1c4
movl 0xd0(%rsp), %eax
cmpl $0x1, %eax
je 0xc19b
testl %eax, %eax
jne 0xc1b5
xorl %eax, %eax
cmpq $0x0, (%rsp)
setne %al
movl %eax, (%r14)
jmp 0xc1b1
xorpd %xmm0, %xmm0
cmpneqsd 0x8(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movl %eax, (%r14)
xorl %ebp, %ebp
jmp 0xc1c4
leaq 0xa824(%rip), %rax      # 0x169e0
movq %rax, (%r15)
movl $0x1, %ebp
leaq 0x38(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xc1e6
leaq 0xa82c(%rip), %rdx      # 0x16a05
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_O1/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 0xbfb1
movl %eax, %ebp
testl %eax, %eax
je 0xc24b
leaq 0x40(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xc23d
leaq 0xa7d5(%rip), %rdx      # 0x16a05
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 0xc273
testl %eax, %eax
jne 0xc28c
movq (%r14), %rdi
movq 0x8(%rsp), %rdx
leaq 0x9b4e(%rip), %rsi      # 0x15db8
xorl %eax, %eax
callq 0x45d0
jmp 0xc21b
movq (%r14), %rdi
movsd 0x10(%rsp), %xmm0
leaq 0xa264(%rip), %rsi      # 0x164e7
movb $0x1, %al
callq 0x45d0
jmp 0xc21b
leaq 0x40(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xc2b2
movq %rsi, (%r14)
movq 0xfcfc(%rip), %rcx      # 0x1bfa0
movq %rcx, 0x8(%r14)
movq %rax, 0x18(%rsp)
jmp 0xc21b
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x44e0
jmp 0xc21b
// File: /workspace/github_c_makefile_star2_O1/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 0xd119
leaq 0x10(%rbx), %rsi
callq *0x28(%rbx)
movl 0xd0(%rbx), %eax
cmpl $0x1, %eax
je 0xd13f
testl %eax, %eax
jne 0xd156
movq (%rbx), %rdx
movq 0x10(%rbx), %rdi
leaq 0x8c82(%rip), %rsi      # 0x15db8
xorl %eax, %eax
callq 0x45d0
jmp 0xd156
movq 0x10(%rbx), %rdi
movsd 0x8(%rbx), %xmm0
leaq 0x9398(%rip), %rsi      # 0x164e7
movb $0x1, %al
callq 0x45d0
movl $0x2, 0xd0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %r13
xorl %edi, %edi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x43c0
movq %rax, %r12
movq (%r13), %r13
movsbq (%r13), %r14
testq %r14, %r14
setne %bpl
je 0xd37c
callq 0x4640
movq (%rax), %rcx
testb $0x20, 0x1(%rcx,%r14,2)
je 0xd37c
incq %r13
movq %r13, %rcx
movq %rcx, %r13
movq %rcx, 0x10(%rsp)
movsbq (%rcx), %rdx
testq %rdx, %rdx
setne %bpl
je 0xd37c
movq (%rax), %rsi
leaq 0x1(%r13), %rcx
testb $0x20, 0x1(%rsi,%rdx,2)
jne 0xd359
cmpq %rbx, %r13
setne %al
xorb $0x1, %bpl
testb %bpl, %al
jne 0xd3b2
leaq 0x97e8(%rip), %rsi      # 0x16b7a
leaq 0x7f16(%rip), %rcx      # 0x152af
movq 0x8(%rsp), %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
jmp 0xd3b7
movl %r12d, (%r15)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %r13
xorl %edi, %edi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x43c0
movq %rax, %r12
movq (%r13), %r13
movsbq (%r13), %r14
testq %r14, %r14
setne %bpl
je 0xd43e
callq 0x4640
movq (%rax), %rcx
testb $0x20, 0x1(%rcx,%r14,2)
je 0xd43e
incq %r13
movq %r13, %rcx
movq %rcx, %r13
movq %rcx, 0x10(%rsp)
movsbq (%rcx), %rdx
testq %rdx, %rdx
setne %bpl
je 0xd43e
movq (%rax), %rsi
leaq 0x1(%r13), %rcx
testb $0x20, 0x1(%rsi,%rdx,2)
jne 0xd41b
cmpq %rbx, %r13
setne %al
xorb $0x1, %bpl
testb %bpl, %al
jne 0xd474
leaq 0x9726(%rip), %rsi      # 0x16b7a
leaq 0x7e54(%rip), %rcx      # 0x152af
movq 0x8(%rsp), %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
jmp 0xd479
movq %r12, (%r15)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxGet.c
// Function: Hax_GetLongLong
int
Hax_GetLongLong(
    Hax_Interp *interp,		/* Interpreter to use for error reporting. */
    char *string,		/* String containing a (possibly signed)
				 * integer in a form acceptable to strtol. */
    long long int *llongPtr	/* Place to store converted result. */)
{
    char *end;
    long long int i;

    i = Strtoll(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;
    }
    *llongPtr = i;
    return HAX_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %r13
xorl %edi, %edi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x41e0
movq %rax, %r12
movq (%r13), %r13
movsbq (%r13), %r14
testq %r14, %r14
setne %bpl
je 0xd500
callq 0x4640
movq (%rax), %rcx
testb $0x20, 0x1(%rcx,%r14,2)
je 0xd500
incq %r13
movq %r13, %rcx
movq %rcx, %r13
movq %rcx, 0x10(%rsp)
movsbq (%rcx), %rdx
testq %rdx, %rdx
setne %bpl
je 0xd500
movq (%rax), %rsi
leaq 0x1(%r13), %rcx
testb $0x20, 0x1(%rsi,%rdx,2)
jne 0xd4dd
cmpq %rbx, %r13
setne %al
xorb $0x1, %bpl
testb %bpl, %al
jne 0xd536
leaq 0x9664(%rip), %rsi      # 0x16b7a
leaq 0x7d92(%rip), %rcx      # 0x152af
movq 0x8(%rsp), %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
jmp 0xd53b
movq %r12, (%r15)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxGet.c
// Function: Hax_GetDouble
int
Hax_GetDouble(
    Hax_Interp *interp,		/* Interpreter to use for error reporting. */
    char *string,		/* String containing a floating-point number
				 * in a form acceptable to strtod. */
    void *doublePtr		/* Place to store converted result. */)
{
    char *end;
    double d;

    d = strtod(string, &end);
    while ((*end != '\0') && isspace(*end)) {
	end++;
    }
    if ((end == string) || (*end != 0)) {
	Hax_AppendResult(interp, "expected floating-point number but got \"",
		string, "\"", (char *) NULL);
	return HAX_ERROR;
    }
    *(double *)doublePtr = d;
    return HAX_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x4150
movq (%r12), %r12
movsbq (%r12), %r13
testq %r13, %r13
setne %bpl
je 0xd5c9
movsd %xmm0, 0x8(%rsp)
callq 0x4640
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r13,2)
jne 0xd5a1
movsd 0x8(%rsp), %xmm0
jmp 0xd5c9
incq %r12
movq %r12, %rcx
movsd 0x8(%rsp), %xmm0
movq %rcx, %r12
movsbq (%rcx), %rdx
testq %rdx, %rdx
setne %bpl
je 0xd5c9
leaq 0x1(%r12), %rcx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0xd5ad
movq %r12, 0x10(%rsp)
cmpq %rbx, %r12
setne %al
xorb $0x1, %bpl
testb %bpl, %al
jne 0xd602
leaq 0x95b1(%rip), %rsi      # 0x16b95
leaq 0x7cc4(%rip), %rcx      # 0x152af
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
jmp 0xd609
movsd %xmm0, (%r15)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxHash.c
// Function: StringFind
static unsigned int
HashString(
    char *string	/* String from which to compute hash value. */)
{
    unsigned int result;
    int c;

    /*
     * I tried a zillion different hash functions and asked many other
     * people for advice.  Many people had their own favorite functions,
     * all different, but no-one had much idea why they were good ones.
     * I chose the one below (multiply by 9 and add new character)
     * because of the following reasons:
     *
     * 1. Multiplying by 10 is perfect for keys that are decimal strings,
     *    and multiplying by 9 is just about as good.
     * 2. Times-9 is (shift-left-3) plus (old).  This means that each
     *    character's bits hang around in the low-order bits of the
     *    hash value for ever, plus they spread fairly rapidly up to
     *    the high-order bits to fill out the hash value.  This seems
     *    works well both for decimal and non-decimal strings.
     */

    result = 0;
    while (1) {
	c = *string;
	string++;
	if (c == 0) {
	    break;
	}
	result += (result<<3) + c;
    }
    return result;
}

// Assembly:
movb (%rsi), %dl
testb %dl, %dl
je 0xd85e
leaq 0x1(%rsi), %rcx
xorl %eax, %eax
movsbl %dl, %edx
leal (%rax,%rax,8), %eax
addl %edx, %eax
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xd84b
jmp 0xd860
xorl %eax, %eax
andl 0x38(%rdi), %eax
cltq
movq (%rdi), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0xd89e
movb (%rsi), %cl
cmpb 0x20(%rax), %cl
jne 0xd896
movl $0x21, %edx
movl %ecx, %edi
testb %dil, %dil
je 0xd8a0
movb -0x20(%rsi,%rdx), %dil
leaq 0x1(%rdx), %r8
cmpb (%rax,%rdx), %dil
movq %r8, %rdx
je 0xd87f
movq (%rax), %rax
testq %rax, %rax
jne 0xd873
xorl %eax, %eax
retq