LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxParse.c
// Function: QuoteEnd
static char *
QuoteEnd(
    char *string,		/* Pointer to character just after opening
				 * "quote". */
    int term			/* This character will terminate the
				 * quoted string (e.g. '"' or ')'). */)
{
    char *p = string;
    int count;

    while (*p != term) {
	if (*p == '\\') {
	    (void) Hax_Backslash(p, &count);
	    p += count;
	} else if (*p == '[') {
	    for (p++; *p != ']'; p++) {
		p = HaxWordEnd(p, 1);
		if (*p == 0) {
		    return p;
		}
	    }
	    p++;
	} else if (*p == '$') {
	    p = VarNameEnd(p);
	    if (*p == 0) {
		return p;
	    }
	    p++;
	} else if (*p == 0) {
	    return p;
	} else {
	    p++;
	}
    }
    return p-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x1688d
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x167b6
movq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x42a0
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x16888
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x16823
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
je 0x16815
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x4190
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x16805
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16899
jmp 0x16807
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x167ce
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x16886
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x24, %eax
jne 0x16860
movq -0x20(%rbp), %rdi
callq 0x168b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x16852
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16899
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x16884
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x16876
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16899
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x16884
jmp 0x16886
jmp 0x16888
jmp 0x16777
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxParse.c
// Function: VarNameEnd
static char *
VarNameEnd(
    char *string		/* Pointer to dollar-sign character. */)
{
    char *p = string+1;

    if (*p == '{') {
	for (p++; (*p != '}') && (*p != 0); p++) {
	    /* Empty loop body. */
	}
	return p;
    }
    while (isalnum(*p) || (*p == '_')) {
	p++;
    }
    if ((*p == '(') && (p != string+1)) {
	return QuoteEnd(p+1, ')');
    }
    return p-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0x16927
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x7d, %ecx
movb %al, -0x19(%rbp)
je 0x16901
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1690a
jmp 0x1691a
jmp 0x1690c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x168e0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x169b4
jmp 0x16929
callq 0x4630
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x8, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
jne 0x1695c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x16965
jmp 0x16973
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x16929
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x169a8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
je 0x169a8
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movl $0x29, %esi
callq 0x16760
movq %rax, -0x8(%rbp)
jmp 0x169b4
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxProc.c
// Function: ProcDeleteProc
static void
ProcDeleteProc(
    Hax_Interp *interp,
    ClientData clientData		/* Procedure to be deleted. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Proc *procPtr = (Proc *) clientData;
    Arg *argPtr;

    ckfree(memoryp, (char *) procPtr->command);
    for (argPtr = procPtr->argPtr; argPtr != NULL; ) {
	Arg *nextPtr = argPtr->nextPtr;

	ckfree(memoryp, (char *) argPtr);
	argPtr = nextPtr;
    }
    ckfree(memoryp, (char *) procPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x8125(%rip), %rdx      # 0x1f2d7
movl $0x236, %ecx            # imm = 0x236
callq 0x4260
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x171fd
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq 0x80ee(%rip), %rdx      # 0x1f2d7
movl $0x23a, %ecx            # imm = 0x23A
callq 0x4260
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x171c8
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x80cb(%rip), %rdx      # 0x1f2d7
movl $0x23d, %ecx            # imm = 0x23D
callq 0x4260
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxProc.c
// Function: HaxFindProc
Proc *
HaxFindProc(
    Interp *iPtr,		/* Interpreter in which to look. */
    char *procName		/* Name of desired procedure. */)
{
    Hax_HashEntry *hPtr;
    Command *cmdPtr;

    hPtr = Hax_FindHashEntry(&iPtr->commandTable, procName);
    if (hPtr == NULL) {
	return NULL;
    }
    cmdPtr = (Command *) Hax_GetHashValue(hPtr);
    if (cmdPtr->proc != InterpProc) {
	return NULL;
    }
    return (Proc *) cmdPtr->clientData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1759b
movq $0x0, -0x8(%rbp)
jmp 0x175cd
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
leaq -0x7c2(%rip), %rcx      # 0x16df0
cmpq %rcx, (%rax)
je 0x175c1
movq $0x0, -0x8(%rbp)
jmp 0x175cd
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUtil.c
// Function: Hax_ResetResult
void
Hax_ResetResult(
    Hax_Interp *interp		/* Interpreter for which to clear result. */)
{
    Interp *iPtr = (Interp *) interp;

    Hax_FreeResult(interp);
    iPtr->result = iPtr->resultSpace;
    iPtr->resultSpace[0] = 0;
    iPtr->flags &=
	    ~(ERR_ALREADY_LOGGED | ERR_IN_PROGRESS | ERROR_CODE_SET);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x17b73
movq -0x8(%rbp), %rax
movq 0xb47e(%rip), %rcx      # 0x22fa8
cmpq %rcx, 0x8(%rax)
jne 0x17b56
movq -0x8(%rbp), %rdi
callq 0x4540
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x7ce0(%rip), %rdx      # 0x1f82a
movl $0x4c9, %ecx            # imm = 0x4C9
callq 0x4260
jmp 0x17b67
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x17b75
movq -0x10(%rbp), %rcx
addq $0x1b0, %rcx            # imm = 0x1B0
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1b0(%rax)
movq -0x10(%rbp), %rax
movl 0x1a0(%rax), %ecx
andl $-0xf, %ecx
movl %ecx, 0x1a0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUtil.c
// Function: HaxCopyAndCollapse
void
HaxCopyAndCollapse(
    int count,			/* Total number of characters to copy
				 * from src. */
    char *src,		/* Copy from here... */
    char *dst		/* ... to here. */)
{
    char c;
    int numRead;

    for (c = *src; count > 0; src++, c = *src, count--) {
	if (c == '\\') {
	    *dst = Hax_Backslash(src, &numRead);
	    if (*dst != 0) {
		dst++;
	    }
	    src += numRead-1;
	    count -= numRead-1;
	} else {
	    *dst = c;
	    dst++;
	}
    }
    *dst = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x17dca
movsbl -0x19(%rbp), %eax
cmpl $0x5c, %eax
jne 0x17d90
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x42a0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x17d6c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x17da5
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x17da7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x17d2c
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUtil.c
// Function: Hax_AppendElement
void
Hax_AppendElement(
    Hax_Interp *interp,		/* Interpreter whose result is to be
				 * extended. */
    char *string,		/* String to convert to list element and
				 * add to result. */
    int noSep			/* If non-zero, then don't output a
				 * space character before this element,
				 * even if the element isn't the first
				 * thing in the output buffer. */)
{
    Interp *iPtr = (Interp *) interp;
    int size, flags;
    char *dst;

    /*
     * See how much space is needed, and grow the append buffer if
     * needed to accommodate the list element.
     */

    size = Hax_ScanElement(string, &flags) + 1;
    if ((iPtr->result != iPtr->appendResult)
	   || ((size + iPtr->appendUsed) >= iPtr->appendAvl)) {
       SetupAppendBuffer(iPtr, size+iPtr->appendUsed);
    }

    /*
     * Convert the string into a list element and copy it to the
     * buffer that's forming.
     */

    dst = iPtr->appendResult + iPtr->appendUsed;
    if (!noSep && (iPtr->appendUsed != 0)) {
	iPtr->appendUsed++;
	*dst = ' ';
	dst++;
    }
    iPtr->appendUsed += Hax_ConvertElement(string, dst, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4100
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x118(%rcx), %rax
jne 0x18efb
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
addl 0x124(%rcx), %eax
movq -0x20(%rbp), %rcx
cmpl 0x120(%rcx), %eax
jl 0x18f11
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rax
addl 0x124(%rax), %esi
callq 0x18ca0
movq -0x20(%rbp), %rax
movq 0x118(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x124(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x18f67
movq -0x20(%rbp), %rax
cmpl $0x0, 0x124(%rax)
je 0x18f67
movq -0x20(%rbp), %rax
movl 0x124(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x124(%rax)
movq -0x30(%rbp), %rax
movb $0x20, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0x4150
movl %eax, %ecx
movq -0x20(%rbp), %rax
addl 0x124(%rax), %ecx
movl %ecx, 0x124(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUtil.c
// Function: Hax_SetErrorCode
void
	/* VARARGS2 */ /* ARGSUSED */
Hax_SetErrorCode(
    Hax_Interp *interp,		/* Interpreter whose errorCode variable is
				 * to be set. */
    ...				/* One or more elements to add to errorCode,
				 * terminated with NULL. */)
{
    va_list argList;
    char *string;
    int flags;
    Interp *iPtr;

    /*
     * Scan through the arguments one at a time, appending them to
     * $errorCode as list elements.
     */

    va_start(argList, interp);
    iPtr = (Interp *) interp;
    flags = HAX_GLOBAL_ONLY | HAX_LIST_ELEMENT;
    while (1) {
	string = va_arg(argList, char *);
	if (string == NULL) {
	    break;
	}
	(void) Hax_SetVar2((Hax_Interp *) iPtr, (char *) "errorCode",
		(char *) NULL, string, flags);
	flags |= HAX_APPEND_VALUE;
    }
    va_end(argList);
    iPtr->flags |= ERROR_CODE_SET;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x18fcb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x5, -0x2c(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x19060
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x1907d
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x19094
jmp 0x190be
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
leaq 0x427f(%rip), %rsi      # 0x1d326
xorl %eax, %eax
movl %eax, %edx
callq 0x40c0
movl -0x2c(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x2c(%rbp)
jmp 0x19025
movq -0x38(%rbp), %rax
movl 0x1a0(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0x1a0(%rax)
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxUtil.c
// Function: HaxGetListIndex
int
HaxGetListIndex(
    Hax_Interp *interp,			/* Interpreter for error reporting. */
    char *string,			/* String containing list index. */
    long int *indexPtr			/* Where to store index. */)
{
    if (isdigit(*string) || (*string == '-')) {
	if (Hax_GetLong(interp, string, indexPtr) != HAX_OK) {
	    return HAX_ERROR;
	}
	if (*indexPtr < 0) {
	    *indexPtr = 0;
	}
    } else if (strncmp(string, "end", strlen(string)) == 0) {
	*indexPtr = 1<<30;
    } else {
	Hax_AppendResult(interp, "bad index \"", string,
		"\": must be integer or \"end\"", (char *) NULL);
	return HAX_ERROR;
    }
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x4630
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x19120
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x19159
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x44b0
cmpl $0x0, %eax
je 0x19142
movl $0x1, -0x4(%rbp)
jmp 0x191c3
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jge 0x19157
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0x191bc
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41b0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x3fb8(%rip), %rsi      # 0x1d130
callq 0x40a0
cmpl $0x0, %eax
jne 0x1918f
movq -0x20(%rbp), %rax
movq $0x40000000, (%rax)     # imm = 0x40000000
jmp 0x191ba
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x66b6(%rip), %rsi      # 0x1f854
leaq 0x66bb(%rip), %rcx      # 0x1f860
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x191c3
jmp 0x191bc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxVar.c
// Function: Hax_GetVar
char *
Hax_GetVar(
    Hax_Interp *interp,		/* Command interpreter in which varName is
				 * to be looked up. */
    char *varName,		/* Name of a variable in interp. */
    int flags			/* OR-ed combination of HAX_GLOBAL_ONLY
				 * or HAX_LEAVE_ERR_MSG bits. */)
{
    char *p;

    /*
     * If varName refers to an array (it ends with a parenthesized
     * element name), then handle it specially.
     */

    for (p = varName; *p != '\0'; p++) {
	if (*p == '(') {
	    char *result;
	    char *open = p;

	    do {
		p++;
	    } while (*p != '\0');
	    p--;
	    if (*p != ')') {
		goto scalar;
	    }
	    *open = '\0';
	    *p = '\0';
	    result = Hax_GetVar2(interp, varName, open+1, flags);
	    *open = '(';
	    *p = ')';
	    return result;
	}
    }

    scalar:
    return Hax_GetVar2(interp, varName, (char *) NULL, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x195f6
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x195e3
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1956f
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0x195a1
jmp 0x195f8
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x1, %rdx
movl -0x1c(%rbp), %ecx
callq 0x44a0
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movb $0x28, (%rax)
movq -0x28(%rbp), %rax
movb $0x29, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19610
jmp 0x195e5
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1954b
jmp 0x195f8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x44a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxVar.c
// Function: VarErrMsg
static void
VarErrMsg(
    Hax_Interp *interp,		/* Interpreter in which to record message. */
    char *part1, char *part2,	/* Variable's two-part name. */
    char *operation,		/* String describing operation that failed,
				 * e.g. "read", "set", or "unset". */
    char *reason		/* String describing why operation failed. */)
{
    Hax_ResetResult(interp);
    Hax_AppendResult(interp, "can't ", operation, " \"", part1, (char *) NULL);
    if (part2 != NULL) {
	Hax_AppendResult(interp, "(", part2, ")", (char *) NULL);
    }
    Hax_AppendResult(interp, "\": ", reason, (char *) NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42b0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %r8
leaq 0x6237(%rip), %rsi      # 0x1fb6f
leaq 0x3930(%rip), %rcx      # 0x1d26f
xorl %eax, %eax
movl %eax, %r9d
movb $0x0, %al
callq 0x4500
cmpq $0x0, -0x18(%rbp)
je 0x19974
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x50cd(%rip), %rsi      # 0x1ea2e
leaq 0x595c(%rip), %rcx      # 0x1f2c4
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x61f3(%rip), %rsi      # 0x1fb76
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x4500
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxVar.c
// Function: Hax_SetVar
char *
Hax_SetVar(
    Hax_Interp *interp,		/* Command interpreter in which varName is
				 * to be looked up. */
    char *varName,		/* Name of a variable in interp. */
    char *newValue,		/* New value for varName. */
    int flags			/* Various flags that tell how to set value:
				 * any of HAX_GLOBAL_ONLY, HAX_APPEND_VALUE,
				 * HAX_LIST_ELEMENT, HAX_NO_SPACE, or
				 * HAX_LEAVE_ERR_MSG. */)
{
    char *p;

    /*
     * If varName refers to an array (it ends with a parenthesized
     * element name), then handle it specially.
     */

    for (p = varName; *p != '\0'; p++) {
	if (*p == '(') {
	    char *result;
	    char *open = p;

	    do {
		p++;
	    } while (*p != '\0');
	    p--;
	    if (*p != ')') {
		goto scalar;
	    }
	    *open = '\0';
	    *p = '\0';
	    result = Hax_SetVar2(interp, varName, open+1, newValue, flags);
	    *open = '(';
	    *p = ')';
	    return result;
	}
    }

    scalar:
    return Hax_SetVar2(interp, varName, (char *) NULL, newValue, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x19c83
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x19c70
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x19bf7
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0x19c29
jmp 0x19c85
movq -0x40(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq $0x1, %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0x40c0
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movb $0x28, (%rax)
movq -0x30(%rbp), %rax
movb $0x29, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19ca2
jmp 0x19c72
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x19bcf
jmp 0x19c85
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
xorl %eax, %eax
movl %eax, %edx
callq 0x40c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxVar.c
// Function: NewVar
static Var *
NewVar(
    Hax_Interp *interp,
    int space		/* Minimum amount of space to allocate
			 * for variable's value. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    int extra;
    Var *varPtr;

    extra = space - sizeof(varPtr->value);
    if (extra < 0) {
	extra = 0;
	space = sizeof(varPtr->value);
    }
    varPtr = (Var *) ckalloc(memoryp, (unsigned) (sizeof(Var) + extra));
    varPtr->valueLength = 0;
    varPtr->valueSpace = space;
    varPtr->upvarUses = 0;
    varPtr->tracePtr = NULL;
    varPtr->searchPtr = NULL;
    varPtr->flags = 0;
    varPtr->value.string[0] = 0;
    return varPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x20(%rbp)
movslq -0xc(%rbp), %rax
subq $0x8, %rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x1a225
movl $0x0, -0x24(%rbp)
movl $0x8, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rax
addq $0x30, %rax
movl %eax, %eax
movl %eax, %esi
leaq 0x5673(%rip), %rdx      # 0x1f8af
movl $0x825, %ecx            # imm = 0x825
callq 0x44c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0x28(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxVar.c
// Function: DeleteSearches
static void
DeleteSearches(
    Hax_Interp *interp,
    Var *arrayVarPtr		/* Variable whose searches are
				 * to be deleted. */)
{
    Interp *iPtr = (Interp *) interp;
    Hax_Memoryp *memoryp = iPtr->memoryp;
    ArraySearch *searchPtr;

    while (arrayVarPtr->searchPtr != NULL) {
	searchPtr = arrayVarPtr->searchPtr;
	arrayVarPtr->searchPtr = searchPtr->nextPtr;
	ckfree(memoryp, (char *) searchPtr);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1a309
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x55b2(%rip), %rdx      # 0x1f8af
movl $0x894, %ecx            # imm = 0x894
callq 0x4260
jmp 0x1a2c7
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxVar.c
// Function: Hax_UnsetVar
int
Hax_UnsetVar(
    Hax_Interp *interp,		/* Command interpreter in which varName is
				 * to be looked up. */
    char *varName,		/* Name of a variable in interp.  May be
				 * either a scalar name or an array name
				 * or an element in an array. */
    int flags			/* OR-ed combination of any of
				 * HAX_GLOBAL_ONLY or HAX_LEAVE_ERR_MSG. */)
{
    char *p;
    int result;

    /*
     * Figure out whether this is an array reference, then call
     * Hax_UnsetVar2 to do all the real work.
     */

    for (p = varName; *p != '\0'; p++) {
	if (*p == '(') {
	    char *open = p;

	    do {
		p++;
	    } while (*p != '\0');
	    p--;
	    if (*p != ')') {
		goto scalar;
	    }
	    *open = '\0';
	    *p = '\0';
	    result = Hax_UnsetVar2(interp, varName, open+1, flags);
	    *open = '(';
	    *p = ')';
	    return result;
	}
    }

    scalar:
    return Hax_UnsetVar2(interp, varName, (char *) NULL, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1a3d3
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x1a3c0
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1a34f
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0x1a381
jmp 0x1a3d5
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x1, %rdx
movl -0x1c(%rbp), %ecx
callq 0x4280
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movb $0x28, (%rax)
movq -0x28(%rbp), %rax
movb $0x29, (%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a3ec
jmp 0x1a3c2
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1a32b
jmp 0x1a3d5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x4280
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxVar.c
// Function: Hax_TraceVar
int
Hax_TraceVar(
    Hax_Interp *interp,		/* Interpreter in which variable is
				 * to be traced. */
    char *varName,		/* Name of variable;  may end with "(index)"
				 * to signify an array reference. */
    int flags,			/* OR-ed collection of bits, including any
				 * of HAX_TRACE_READS, HAX_TRACE_WRITES,
				 * HAX_TRACE_UNSETS, and HAX_GLOBAL_ONLY. */
    Hax_VarTraceProc *proc,	/* Procedure to call when specified ops are
				 * invoked upon varName. */
    ClientData clientData	/* Arbitrary argument to pass to proc. */)
{
    char *p;

    /*
     * If varName refers to an array (it ends with a parenthesized
     * element name), then handle it specially.
     */

    for (p = varName; *p != '\0'; p++) {
	if (*p == '(') {
	    int result;
	    char *open = p;

	    do {
		p++;
	    } while (*p != '\0');
	    p--;
	    if (*p != ')') {
		goto scalar;
	    }
	    *open = '\0';
	    *p = '\0';
	    result = Hax_TraceVar2(interp, varName, open+1, flags,
		    proc, clientData);
	    *open = '(';
	    *p = ')';
	    return result;
	}
    }

    scalar:
    return Hax_TraceVar2(interp, varName, (char *) NULL, flags,
	    proc, clientData);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1aa97
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x1aa84
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1aa0b
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0x1aa3d
jmp 0x1aa99
movq -0x48(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq $0x1, %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x41d0
movl %eax, -0x3c(%rbp)
movq -0x48(%rbp), %rax
movb $0x28, (%rax)
movq -0x38(%rbp), %rax
movb $0x29, (%rax)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1aab8
jmp 0x1aa86
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1a9e3
jmp 0x1aa99
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
xorl %eax, %eax
movl %eax, %edx
callq 0x41d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxVar.c
// Function: Hax_UntraceVar
void
Hax_UntraceVar(
    Hax_Interp *interp,		/* Interpreter containing traced variable. */
    char *varName,		/* Name of variable;  may end with "(index)"
				 * to signify an array reference. */
    int flags,			/* OR-ed collection of bits describing
				 * current trace, including any of
				 * HAX_TRACE_READS, HAX_TRACE_WRITES,
				 * HAX_TRACE_UNSETS, and HAX_GLOBAL_ONLY. */
    Hax_VarTraceProc *proc,	/* Procedure assocated with trace. */
    ClientData clientData	/* Arbitrary argument to pass to proc. */)
{
    char *p;

    /*
     * If varName refers to an array (it ends with a parenthesized
     * element name), then handle it specially.
     */

    for (p = varName; *p != '\0'; p++) {
	if (*p == '(') {
	    char *open = p;

	    do {
		p++;
	    } while (*p != '\0');
	    p--;
	    if (*p != ')') {
		goto scalar;
	    }
	    *open = '\0';
	    *p = '\0';
	    Hax_UntraceVar2(interp, varName, open+1, flags, proc, clientData);
	    *open = '(';
	    *p = ')';
	    return;
	}
    }

    scalar:
    Hax_UntraceVar2(interp, varName, (char *) NULL, flags, proc, clientData);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1ae5a
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x1ae47
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1add7
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0x1ae09
jmp 0x1ae5c
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x1, %rdx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0x4600
movq -0x38(%rbp), %rax
movb $0x28, (%rax)
movq -0x30(%rbp), %rax
movb $0x29, (%rax)
jmp 0x1ae78
jmp 0x1ae49
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1adb3
jmp 0x1ae5c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
xorl %eax, %eax
movl %eax, %edx
callq 0x4600
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxVar.c
// Function: Hax_VarTraceInfo
ClientData
Hax_VarTraceInfo(
    Hax_Interp *interp,		/* Interpreter containing variable. */
    char *varName,		/* Name of variable;  may end with "(index)"
				 * to signify an array reference. */
    int flags,			/* 0 or HAX_GLOBAL_ONLY. */
    Hax_VarTraceProc *proc,	/* Procedure assocated with trace. */
    ClientData prevClientData	/* If non-NULL, gives last value returned
				 * by this procedure, so this call will
				 * return the next trace after that one.
				 * If NULL, this call will return the
				 * first trace. */)
{
    char *p;

    /*
     * If varName refers to an array (it ends with a parenthesized
     * element name), then handle it specially.
     */

    for (p = varName; *p != '\0'; p++) {
	if (*p == '(') {
	    ClientData result;
	    char *open = p;

	    do {
		p++;
	    } while (*p != '\0');
	    p--;
	    if (*p != ')') {
		goto scalar;
	    }
	    *open = '\0';
	    *p = '\0';
	    result = Hax_VarTraceInfo2(interp, varName, open+1, flags, proc,
		prevClientData);
	    *open = '(';
	    *p = ')';
	    return result;
	}
    }

    scalar:
    return Hax_VarTraceInfo2(interp, varName, (char *) NULL, flags, proc,
	    prevClientData);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1b17a
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x1b167
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1b0eb
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0x1b11d
jmp 0x1b17c
movq -0x48(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq $0x1, %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x4320
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
movb $0x28, (%rax)
movq -0x38(%rbp), %rax
movb $0x29, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b19c
jmp 0x1b169
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1b0c3
jmp 0x1b17c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
xorl %eax, %eax
movl %eax, %edx
callq 0x4320
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxVar.c
// Function: Hax_SetCmd
int
Hax_SetCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,	/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    if (argc == 2) {
	char *value;

	value = Hax_GetVar(interp, argv[1], HAX_LEAVE_ERR_MSG);
	if (value == NULL) {
	    return HAX_ERROR;
	}
	interp->result = value;
	return HAX_OK;
    } else if (argc == 3) {
	char *result;

	result = Hax_SetVar(interp, argv[1], argv[2], HAX_LEAVE_ERR_MSG);
	if (result == NULL) {
	    return HAX_ERROR;
	}
	interp->result = result;
	return HAX_OK;
    } else {
	Hax_AppendResult(interp, "wrong # args: should be \"",
		argv[0], " varName ?newValue?\"", (char *) NULL);
	return HAX_ERROR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2, -0x1c(%rbp)
jne 0x1b3de
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x4550
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1b3ca
movl $0x1, -0x4(%rbp)
jmp 0x1b456
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1b456
cmpl $0x3, -0x1c(%rbp)
jne 0x1b42a
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x200, %ecx            # imm = 0x200
callq 0x4450
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x1b416
movl $0x1, -0x4(%rbp)
jmp 0x1b456
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1b456
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x2538(%rip), %rsi      # 0x1d974
leaq 0x4475(%rip), %rcx      # 0x1f8b8
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxVar.c
// Function: Hax_UnsetCmd
int
Hax_UnsetCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    int i;

    if (argc < 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"",
		argv[0], " varName ?varName ...?\"", (char *) NULL);
	return HAX_ERROR;
    }
    for (i = 1; i < argc; i++) {
	if (Hax_UnsetVar(interp, argv[i], HAX_LEAVE_ERR_MSG) != 0) {
	    return HAX_ERROR;
	}
    }
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0x1b4ab
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x24e5(%rip), %rsi      # 0x1d974
leaq 0x4437(%rip), %rcx      # 0x1f8cd
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x1b4f6
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1b4ef
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x4250
cmpl $0x0, %eax
je 0x1b4e2
movl $0x1, -0x4(%rbp)
jmp 0x1b4f6
jmp 0x1b4e4
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1b4b2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxVar.c
// Function: Hax_AppendCmd
int
Hax_AppendCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    int i;
    char *result = NULL;		/* (Initialization only needed to keep
					 * the compiler from complaining) */

    if (argc < 3) {
	Hax_AppendResult(interp, "wrong # args: should be \"",
		argv[0], " varName value ?value ...?\"", (char *) NULL);
	return HAX_ERROR;
    }

    for (i = 2; i < argc; i++) {
	result = Hax_SetVar(interp, argv[1], argv[i],
		HAX_APPEND_VALUE|HAX_LEAVE_ERR_MSG);
	if (result == NULL) {
	    return HAX_ERROR;
	}
    }
    interp->result = result;
    return HAX_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x1b553
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x243d(%rip), %rsi      # 0x1d974
leaq 0x43a7(%rip), %rcx      # 0x1f8e5
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x4500
movl $0x1, -0x4(%rbp)
jmp 0x1b5b7
movl $0x2, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1b5a5
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl $0x202, %ecx            # imm = 0x202
callq 0x4450
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x1b598
movl $0x1, -0x4(%rbp)
jmp 0x1b5b7
jmp 0x1b59a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1b55a
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxPanic.c
// Function: Hax_Panic
void
Hax_Panic(
    char *format,		/* Format string, suitable for passing to
				 * fprintf. */
    ...				/* Additional arguments (variable in number)
				 * to pass to fprintf. */)
{
    va_list va;
    va_start(va, format);
    (void) vfprintf(stderr, format, va);
    (void) fflush(stderr);
    abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x1c775
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x6831(%rip), %rax      # 0x22ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x4530
movq 0x681a(%rip), %rax      # 0x22ff8
movq (%rax), %rdi
callq 0x4420
callq 0x4050
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxStrtol.c
// Function: Strtol
long int
Strtol(
    Interp *iPtr,
    const char *nptr,
    char **endptr,
    int base)
{
    long int result;
    int saved_errno;

    saved_errno = errno;
    errno = 0;
    result = strtol(nptr, endptr, base);
    if (iPtr) {
	iPtr->internalErrno = ErrnoToInternalErrno(errno);
    }
    errno = saved_errno;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
callq 0x4060
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0x4060
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x4360
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c86f
callq 0x4060
movl (%rax), %edi
callq 0x1c890
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x278(%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0x4060
movl -0x30(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxStrtol.c
// Function: ErrnoToInternalErrno
static int
ErrnoToInternalErrno(int e)
{
    switch (e) {
	case 0:
	    return 0;
	case EINVAL:
	    return HAX_EINVAL;
	case ERANGE:
	    return HAX_ERANGE;
	default:
	    Hax_Panic((char *) "Unknown errno=%d\n", e);
    }
    /* NOTREACHABLE */
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x1c8bb
jmp 0x1c8a7
movl -0xc(%rbp), %eax
subl $0x16, %eax
je 0x1c8c4
jmp 0x1c8b1
movl -0xc(%rbp), %eax
subl $0x22, %eax
je 0x1c8cd
jmp 0x1c8d6
movl $0x0, -0x4(%rbp)
jmp 0x1c8ee
movl $0x16, -0x4(%rbp)
jmp 0x1c8ee
movl $0x22, -0x4(%rbp)
jmp 0x1c8ee
movl -0x8(%rbp), %esi
leaq 0x329a(%rip), %rdi      # 0x1fb7a
movb $0x0, %al
callq 0x4120
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxStrtol.c
// Function: Strtoul
unsigned long int
Strtoul(
    Interp *iPtr,
    const char *nptr,
    char **endptr,
    int base)
{
    unsigned long int result;
    int saved_errno;

    saved_errno = errno;
    errno = 0;
    result = strtoul(nptr, endptr, base);
    if (iPtr) {
	iPtr->internalErrno = ErrnoToInternalErrno(errno);
    }
    errno = saved_errno;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
callq 0x4060
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0x4060
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x4560
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c9df
callq 0x4060
movl (%rax), %edi
callq 0x1c890
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x278(%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0x4060
movl -0x30(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/haxlang[P]hax/haxStrtol.c
// Function: Strtod
double
Strtod(
    Interp *iPtr,
    const char *nptr,
    char **endptr)
{
    double result;
    int saved_errno;

    saved_errno = errno;
    errno = 0;
    result = strtod(nptr, endptr);
    if (iPtr) {
	iPtr->internalErrno = ErrnoToInternalErrno(errno);
    }
    errno = saved_errno;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x4060
movl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x4060
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4130
movsd %xmm0, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1ca5a
callq 0x4060
movl (%rax), %edi
callq 0x1c890
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x278(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
callq 0x4060
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: xmalloc
void *xmalloc(size_t len) {
  void *p;

  if (!(p = malloc(len)))
    die("malloc: %s\n", strerror(errno));

  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x51e0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x5a5c
callq 0x5570
movl (%rax), %edi
callq 0x5430
movq %rax, %rsi
leaq 0xbdaa(%rip), %rdi      # 0x117ff
movb $0x0, %al
callq 0x5a70
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)