LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x79b8
movq (%rcx), %rdx
leaq 0xcec3(%rip), %rsi      # 0x14860
leaq 0xd974(%rip), %rcx      # 0x15318
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
jmp 0x79db
decl %edx
addq $0x8, %rcx
movq %rbx, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x4670
movq %rax, (%rbx)
movq 0x135cb(%rip), %rax     # 0x1afa0
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7a4a
movq (%r14), %rdx
leaq 0xce2c(%rip), %rsi      # 0x14860
leaq 0xcef8(%rip), %rcx      # 0x14933
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
jmp 0x7aa3
cmpl $0x3, %r15d
jb 0x7a90
movq 0x10(%r14), %rsi
cmpb $0x0, (%rsi)
je 0x7a68
movq %rbx, %rdi
callq 0x4410
orb $0x4, 0x1a0(%rbx)
cmpl $0x4, %r15d
jne 0x7a90
movq 0x18(%r14), %rcx
leaq 0xc8ec(%rip), %rsi      # 0x14365
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 0x44f0
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7ae3
movq (%rcx), %rdx
leaq 0xcd96(%rip), %rsi      # 0x14860
leaq 0xd847(%rip), %rcx      # 0x15318
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
jmp 0x7b6e
cmpl $0x2, %edx
jne 0x7aff
movq 0x8(%rcx), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45c0
movl %eax, %ebp
jmp 0x7b47
movq 0x280(%rbx), %r14
decl %edx
addq $0x8, %rcx
movq %rbx, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x4670
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45c0
movl %eax, %ebp
leaq 0xcd99(%rip), %rdx      # 0x148d0
movq %r14, %rdi
movq %r15, %rsi
movl $0x196, %ecx            # imm = 0x196
callq 0x4280
cmpl $0x1, %ebp
jne 0x7b73
movl 0x10(%rbx), %edx
leaq 0xcdff(%rip), %rsi      # 0x14955
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x45e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4410
movl $0x1, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7c6d
movq 0x8(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45c0
cmpl $0x1, %eax
je 0x7c8d
testl %eax, %eax
jne 0x7ca1
leaq 0xc(%rsp), %r15
leaq 0xcbb2(%rip), %r12      # 0x147b0
movq 0x10(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4660
testl %eax, %eax
jne 0x7ca1
cmpl $0x0, 0xc(%rsp)
je 0x7cad
movq 0x20(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45c0
cmpl $0x4, %eax
ja 0x7ca1
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 0x45c0
testl %eax, %eax
je 0x7bfe
cmpl $0x3, %eax
je 0x7cad
cmpl $0x1, %eax
jne 0x7ca1
leaq 0xcd63(%rip), %rsi      # 0x149ce
jmp 0x7c94
movq (%r14), %rdx
leaq 0xcbe9(%rip), %rsi      # 0x14860
leaq 0xccff(%rip), %rcx      # 0x1497d
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
jmp 0x7c9c
leaq 0xcd03(%rip), %rsi      # 0x14997
movq %rbx, %rdi
callq 0x4410
movl $0x1, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x42d0
xorl %eax, %eax
jmp 0x7ca1
movl 0x10(%rbx), %edx
leaq 0xccf1(%rip), %rsi      # 0x149b4
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x45e0
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x7c97
// File: /workspace/github_c_makefile_star2_O3/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 0x8633
movq (%r14), %rdx
leaq 0xc248(%rip), %rsi      # 0x14860
leaq 0xc598(%rip), %rcx      # 0x14bb7
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %ebp
jmp 0x8671
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movl $0x200, %edx            # imm = 0x200
callq 0x4560
movl $0x1, %ebp
testq %rax, %rax
je 0x8671
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4600
testl %eax, %eax
je 0x867e
leaq 0xc564(%rip), %rsi      # 0x14bcd
movq %rbx, %rdi
callq 0x4410
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %r15d
jne 0x868e
movq 0x8(%rsp), %rdx
incq %rdx
jmp 0x86b6
movq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x4600
testl %eax, %eax
je 0x86ac
leaq 0xc551(%rip), %rsi      # 0x14bfb
jmp 0x8669
movq 0x8(%rsp), %rdx
addq 0x10(%rsp), %rdx
movq %rdx, 0x8(%rsp)
leaq 0xc552(%rip), %rsi      # 0x14c14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x45e0
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movl $0x200, %ecx            # imm = 0x200
callq 0x4460
testq %rax, %rax
je 0x8671
movq %rax, (%rbx)
xorl %ebp, %ebp
jmp 0x8671
// File: /workspace/github_c_makefile_star2_O3/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 0x9160
cmpl $0x3, %edx
jne 0x91ee
movq 0x10(%rcx), %r15
jmp 0x9167
leaq 0xcacd(%rip), %r15      # 0x15c34
movq 0x8(%rcx), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x4530
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x9211
cmpl $0x0, 0xc(%rsp)
jle 0x91d1
xorl %r12d, %r12d
movq 0x10(%rsp), %rax
testq %r12, %r12
je 0x91b5
movq (%rax,%r12,8), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x4510
jmp 0x91c4
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x4510
incq %r12
movslq 0xc(%rsp), %rax
cmpq %rax, %r12
jl 0x9196
movq 0x10(%rsp), %rsi
leaq 0xbd0e(%rip), %rdx      # 0x14eeb
movq %r14, %rdi
movl $0x26c, %ecx            # imm = 0x26C
callq 0x4280
xorl %eax, %eax
jmp 0x9211
movq (%rcx), %rdx
leaq 0xb668(%rip), %rsi      # 0x14860
leaq 0xbcd8(%rip), %rcx      # 0x14ed7
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9324
movq 0x280(%r14), %r15
movq 0x10(%r12), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x44c0
movl $0x1, %ebx
testl %eax, %eax
jne 0x9348
xorl %ebx, %ebx
cmpq $0x0, 0x10(%rsp)
js 0x9348
movq %r15, 0x28(%rsp)
movq 0x8(%r12), %rax
leaq 0x30(%rsp), %r12
movq %rax, (%r12)
leaq 0x20(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x1c(%rsp), %r15
movq 0x30(%rsp), %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %r12, %rcx
movq %rbp, %r8
movq %r15, %r9
callq 0x4370
testl %eax, %eax
jne 0x9359
movq 0x10(%rsp), %rax
leaq -0x1(%rax), %rcx
movq %rcx, 0x10(%rsp)
testq %rax, %rax
jg 0x9290
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
movq 0x28(%rsp), %rdi
je 0x9348
cmpq $0xc7, %rsi
jl 0x92fd
incl %esi
leaq 0xbc06(%rip), %rdx      # 0x14eeb
movl $0x2a5, %ecx            # imm = 0x2A5
callq 0x44d0
movq %rax, (%r14)
movq 0x11ca7(%rip), %rax     # 0x1afa0
movq %rax, 0x8(%r14)
cmpl $0x0, 0x1c(%rsp)
je 0x935d
movq (%r14), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x43b0
movq (%r14), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x9348
movq (%r12), %rdx
leaq 0xb531(%rip), %rsi      # 0x14860
leaq 0xbbc0(%rip), %rcx      # 0x14ef6
movq %r14, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
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 0x9348
movl 0x8(%rsp), %edi
movq 0x20(%rsp), %rsi
movq (%r14), %rdx
callq 0x4160
jmp 0x9348
// File: /workspace/github_c_makefile_star2_O3/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 0x953e
movq (%rcx), %rdx
leaq 0xb33d(%rip), %rsi      # 0x14860
leaq 0xbdee(%rip), %rcx      # 0x15318
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
jmp 0x9561
decl %edx
addq $0x8, %rcx
movq %rbx, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x4520
movq %rax, (%rbx)
movq 0x11a45(%rip), %rax     # 0x1afa0
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x95c2
movq 0x8(%rcx), %rsi
movq %rsi, (%rsp)
xorl %ebx, %ebx
cmpb $0x0, (%rsi)
je 0x95e7
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 0x4370
testl %eax, %eax
jne 0x9600
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x95ea
incq %r15
movq (%rsp), %rsi
cmpb $0x0, (%rsi)
jne 0x9592
jmp 0x95ea
movq (%rcx), %rdx
leaq 0xb294(%rip), %rsi      # 0x14860
leaq 0xb953(%rip), %rcx      # 0x14f26
movq %r14, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %ebx
jmp 0x9602
xorl %r15d, %r15d
movq (%r14), %rdi
leaq 0xbb4b(%rip), %rsi      # 0x1513f
movq %r15, %rdx
xorl %eax, %eax
callq 0x45e0
jmp 0x9602
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_O3/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 0x9b00
movq 0x280(%r14), %rbx
movq 0x8(%r15), %rsi
leaq 0x4(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
callq 0x4530
movl $0x1, %r12d
testl %eax, %eax
jne 0x9b58
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x0, 0x4(%rsp)
jle 0x9b29
xorl %r12d, %r12d
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %rdi
movq 0x10(%r15), %rsi
callq 0x4470
testl %eax, %eax
jne 0x9b26
incq %r12
movslq 0x4(%rsp), %rax
cmpq %rax, %r12
jl 0x9adb
jmp 0x9b29
movq (%r15), %rdx
leaq 0xad56(%rip), %rsi      # 0x14860
leaq 0xb4c4(%rip), %rcx      # 0x14fd5
movq %r14, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %r12d
jmp 0x9b58
movl %r12d, %ebp
movq (%r14), %rdi
leaq 0xa7e0(%rip), %rsi      # 0x14313
xorl %r12d, %r12d
movl %ebp, %edx
xorl %eax, %eax
callq 0x45e0
movq 0x8(%rsp), %rsi
leaq 0xb3a0(%rip), %rdx      # 0x14eeb
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_O3/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 0x9bf6
movq 0x280(%rbx), %r14
movq 0x8(%rcx), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x4530
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x9c19
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
leaq 0x71(%rip), %rcx        # 0x9c21
movl $0x8, %edx
callq 0x4130
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x4520
movq %rax, (%rbx)
movq 0x113cb(%rip), %rax     # 0x1afa0
movq %rax, 0x8(%rbx)
movq 0x10(%rsp), %rsi
leaq 0xb306(%rip), %rdx      # 0x14eeb
movq %r14, %rdi
movl $0x48b, %ecx            # imm = 0x48B
callq 0x4280
xorl %eax, %eax
jmp 0x9c19
movq (%rcx), %rdx
leaq 0xac60(%rip), %rsi      # 0x14860
leaq 0xb31f(%rip), %rcx      # 0x14f26
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa3db
movq 0x10(%r14), %rsi
cmpb $0x0, (%rsi)
je 0xa40a
leaq 0x18(%rbx), %r15
movq %r15, %rdi
callq *0x58(%rbx)
testq %rax, %rax
je 0xa42e
movq 0x10(%r14), %rdx
leaq 0xadf6(%rip), %rsi      # 0x151c8
leaq 0xae01(%rip), %rcx      # 0x151da
jmp 0xa3ec
movq (%r14), %rdx
leaq 0xa47b(%rip), %rsi      # 0x14860
leaq 0xada2(%rip), %rcx      # 0x1518e
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x4310
testl %eax, %eax
je 0xa462
movq 0x8(%r14), %rdx
leaq 0xad7b(%rip), %rsi      # 0x151a0
leaq 0xad83(%rip), %rcx      # 0x151af
jmp 0xa3ec
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq *0x58(%rbx)
testq %rax, %rax
je 0xa466
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 0xa3fe
movq 0x8(%r14), %rdx
leaq 0xad83(%rip), %rsi      # 0x151f4
leaq 0xad8b(%rip), %rcx      # 0x15203
jmp 0xa3ec
// File: /workspace/github_c_makefile_star2_O3/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 0xa4ab
movq (%rcx), %rdx
leaq 0xa3d3(%rip), %rax      # 0x14860
leaq 0xad89(%rip), %rcx      # 0x1521d
movq %rsi, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %ebx
jmp 0xa4cb
movl $0x2, %ebx
cmpl $0x2, %edx
jne 0xa4cb
movq 0x8(%rcx), %rax
movq %rsi, %rdi
movq %rax, %rsi
movq $-0x1, %rdx
callq 0x44f0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa9d2
cmpl $0x3, %edx
jne 0xaa47
movq 0x10(%r14), %r15
jmp 0xa9d9
leaq 0xa91d(%rip), %r15      # 0x152f6
cmpb $0x0, (%r15)
je 0xaa6c
movq 0x8(%r14), %rsi
movb (%rsi), %bpl
testb %bpl, %bpl
je 0xaa9f
leaq 0x1(%r15), %r12
movq %rsi, %r13
movb (%r15), %cl
movq %r12, %rax
testb %cl, %cl
je 0xaa27
cmpb %bpl, %cl
je 0xaa10
movb (%rax), %cl
incq %rax
jmp 0xaa00
movb $0x0, (%r13)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4050
movb %bpl, (%r13)
leaq 0x1(%r13), %rsi
movb 0x1(%r13), %bpl
incq %r13
testb %bpl, %bpl
jne 0xa9fa
cmpq 0x8(%r14), %r13
je 0xaa9f
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4050
jmp 0xaaa1
movq (%r14), %rdx
leaq 0x9e0f(%rip), %rsi      # 0x14860
leaq 0xa8a3(%rip), %rcx      # 0x152fb
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %ebp
jmp 0xaaa1
movb $0x0, 0x7(%rsp)
movq 0x8(%r14), %r15
movb (%r15), %al
testb %al, %al
je 0xaa9f
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 0xaa84
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_O3/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 0xb9e8
movq 0x8(%r14), %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x4660
testl %eax, %eax
jne 0xba0b
leaq 0x96e4(%rip), %r12      # 0x15088
leaq 0xc(%rsp), %r15
cmpl $0x0, 0xc(%rsp)
je 0xba17
movq 0x10(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45c0
cmpl $0x4, %eax
ja 0xba0b
movl %eax, %ecx
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4660
testl %eax, %eax
je 0xb9a9
jmp 0xba0b
movq (%r14), %rdx
leaq 0x8e6e(%rip), %rsi      # 0x14860
leaq 0x9b8b(%rip), %rcx      # 0x15584
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x42d0
xorl %eax, %eax
jmp 0xba0b
movl 0x10(%rbx), %edx
leaq 0x9b66(%rip), %rsi      # 0x15593
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x45e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4410
jmp 0xba06
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xbad9
movl %eax, %ebp
testl %eax, %eax
jne 0xbaa7
movl 0xd0(%rsp), %eax
cmpl $0x1, %eax
je 0xba8a
testl %eax, %eax
jne 0xba98
movq (%rsp), %rax
jmp 0xba91
cvttsd2si 0x8(%rsp), %rax
movq %rax, (%r14)
xorl %ebp, %ebp
jmp 0xbaa7
leaq 0x9d51(%rip), %rax      # 0x157f0
movq %rax, (%r15)
movl $0x1, %ebp
leaq 0x38(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xbac9
leaq 0x9d59(%rip), %rdx      # 0x15815
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_O3/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 0xf4c7(%rip), %rax      # 0x1afd8
movq %rax, 0x28(%rdx)
movq $0x0, 0x30(%rdx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xbdee
testl %eax, %eax
jne 0xbb57
xorl %eax, %eax
cmpl $0x3, 0x10(%rsp)
je 0xbb57
leaq 0x9ce4(%rip), %rsi      # 0x1581f
leaq 0x876d(%rip), %rcx      # 0x142af
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbad9
movl %eax, %ebp
testl %eax, %eax
jne 0xbbba
movl 0xd0(%rsp), %eax
cmpl $0x1, %eax
je 0xbb9d
testl %eax, %eax
jne 0xbbab
movq (%rsp), %rax
jmp 0xbba4
cvttsd2si 0x8(%rsp), %rax
movq %rax, (%r14)
xorl %ebp, %ebp
jmp 0xbbba
leaq 0x9c3e(%rip), %rax      # 0x157f0
movq %rax, (%r15)
movl $0x1, %ebp
leaq 0x38(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xbbdc
leaq 0x9c46(%rip), %rdx      # 0x15815
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_O3/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 0xbad9
movl %eax, %ebp
testl %eax, %eax
jne 0xbcec
movl 0xd0(%rsp), %eax
cmpl $0x1, %eax
je 0xbcc3
testl %eax, %eax
jne 0xbcdd
xorl %eax, %eax
cmpq $0x0, (%rsp)
setne %al
movl %eax, (%r14)
jmp 0xbcd9
xorpd %xmm0, %xmm0
cmpneqsd 0x8(%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movl %eax, (%r14)
xorl %ebp, %ebp
jmp 0xbcec
leaq 0x9b0c(%rip), %rax      # 0x157f0
movq %rax, (%r15)
movl $0x1, %ebp
leaq 0x38(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xbd0e
leaq 0x9b14(%rip), %rdx      # 0x15815
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_O3/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 0xbad9
movl %eax, %ebp
testl %eax, %eax
je 0xbd73
leaq 0x40(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xbd65
leaq 0x9abd(%rip), %rdx      # 0x15815
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 0xbd9b
testl %eax, %eax
jne 0xbdb4
movq (%r14), %rdi
movq 0x8(%rsp), %rdx
leaq 0x8e82(%rip), %rsi      # 0x14c14
xorl %eax, %eax
callq 0x45e0
jmp 0xbd43
movq (%r14), %rdi
movsd 0x10(%rsp), %xmm0
leaq 0x9548(%rip), %rsi      # 0x152f3
movb $0x1, %al
callq 0x45e0
jmp 0xbd43
leaq 0x40(%rsp), %rax
movq -0x28(%rax), %rsi
cmpq %rax, %rsi
je 0xbdda
movq %rsi, (%r14)
movq 0xf1d4(%rip), %rcx      # 0x1afa0
movq %rcx, 0x8(%r14)
movq %rax, 0x18(%rsp)
jmp 0xbd43
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x44f0
jmp 0xbd43
// File: /workspace/github_c_makefile_star2_O3/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 0xcc62
leaq 0x10(%rbx), %rsi
callq *0x28(%rbx)
movl 0xd0(%rbx), %eax
cmpl $0x1, %eax
je 0xcc88
testl %eax, %eax
jne 0xcc9f
movq (%rbx), %rdx
movq 0x10(%rbx), %rdi
leaq 0x7f95(%rip), %rsi      # 0x14c14
xorl %eax, %eax
callq 0x45e0
jmp 0xcc9f
movq 0x10(%rbx), %rdi
movsd 0x8(%rbx), %xmm0
leaq 0x865b(%rip), %rsi      # 0x152f3
movb $0x1, %al
callq 0x45e0
movl $0x2, 0xd0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x43d0
movq %rax, %r12
movq (%r13), %r13
movb (%r13), %bpl
testb %bpl, %bpl
je 0xce98
callq 0x4650
incq %r13
movq (%rax), %rcx
movsbq %bpl, %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0xcea4
movq %r13, (%rsp)
movb (%r13), %bpl
incq %r13
testb %bpl, %bpl
jne 0xce77
decq %r13
cmpq %rbx, %r13
je 0xcea4
movl %r12d, (%r15)
xorl %eax, %eax
jmp 0xcec7
leaq 0x8adf(%rip), %rsi      # 0x1598a
leaq 0x73fd(%rip), %rcx      # 0x142af
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x43d0
movq %rax, %r12
movq (%r13), %r13
movb (%r13), %bpl
testb %bpl, %bpl
je 0xcf32
callq 0x4650
incq %r13
movq (%rax), %rcx
movsbq %bpl, %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0xcf3e
movq %r13, (%rsp)
movb (%r13), %bpl
incq %r13
testb %bpl, %bpl
jne 0xcf11
decq %r13
cmpq %rbx, %r13
je 0xcf3e
movq %r12, (%r15)
xorl %eax, %eax
jmp 0xcf61
leaq 0x8a45(%rip), %rsi      # 0x1598a
leaq 0x7363(%rip), %rcx      # 0x142af
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r13
xorl %edi, %edi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x41e0
movq %rax, %r12
movq (%r13), %r13
movb (%r13), %bpl
testb %bpl, %bpl
je 0xcfcc
callq 0x4650
incq %r13
movq (%rax), %rcx
movsbq %bpl, %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0xcfd8
movq %r13, (%rsp)
movb (%r13), %bpl
incq %r13
testb %bpl, %bpl
jne 0xcfab
decq %r13
cmpq %rbx, %r13
je 0xcfd8
movq %r12, (%r15)
xorl %eax, %eax
jmp 0xcffb
leaq 0x89ab(%rip), %rsi      # 0x1598a
leaq 0x72c9(%rip), %rcx      # 0x142af
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x4150
movq (%r12), %r12
movb (%r12), %bpl
testb %bpl, %bpl
je 0xd066
movsd %xmm0, (%rsp)
callq 0x4650
movsd (%rsp), %xmm0
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0xd074
movb 0x1(%r12), %bpl
incq %r12
testb %bpl, %bpl
jne 0xd04e
cmpq %rbx, %r12
je 0xd074
movsd %xmm0, (%r15)
xorl %eax, %eax
jmp 0xd097
leaq 0x892a(%rip), %rsi      # 0x159a5
leaq 0x722d(%rip), %rcx      # 0x142af
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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), %cl
testb %cl, %cl
je 0xd2cd
leaq 0x1(%rsi), %rdx
xorl %eax, %eax
movl %ecx, %r8d
movsbl %r8b, %r8d
leal (%rax,%rax,8), %eax
addl %r8d, %eax
movb (%rdx), %r8b
incq %rdx
testb %r8b, %r8b
jne 0xd2b6
jmp 0xd2cf
xorl %eax, %eax
andl 0x38(%rdi), %eax
cltq
movq (%rdi), %rdx
movq (%rdx,%rax,8), %rax
testq %rax, %rax
je 0xd308
cmpb 0x20(%rax), %cl
jne 0xd303
movl $0x21, %edx
movl %ecx, %edi
testb %dil, %dil
je 0xd30a
movb -0x20(%rsi,%rdx), %dil
leaq 0x1(%rdx), %r8
cmpb (%rax,%rdx), %dil
movq %r8, %rdx
je 0xd2ec
movq (%rax), %rax
jmp 0xd2db
xorl %eax, %eax
retq