LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxUtil.c
// Function: SetupAppendBuffer
static void
SetupAppendBuffer(
    Interp *iPtr,	/* Interpreter whose result is being set up. */
    int newSpace		/* Make sure that at least this many bytes
				 * of new information may be added. */)
{
    Hax_Memoryp *memoryp = iPtr->memoryp;
    int totalSpace;

    /*
     * Make the append buffer larger, if that's necessary, then
     * copy the current result into the append buffer and make the
     * append buffer the official Hax result.
     */

    if (iPtr->result != iPtr->appendResult) {
	/*
	 * If an oversized buffer was used recently, then free it up
	 * so we go back to a smaller buffer.  This avoids tying up
	 * memory forever after a large operation.
	 */

	if (iPtr->appendAvl > 500) {
	    ckfree(memoryp, iPtr->appendResult);
	    iPtr->appendResult = NULL;
	    iPtr->appendAvl = 0;
	}
	iPtr->appendUsed = strlen(iPtr->result);
    }
    totalSpace = newSpace + iPtr->appendUsed;
    if (totalSpace >= iPtr->appendAvl) {
	char *newPtr;

	if (totalSpace < 100) {
	    totalSpace = 200;
	} else {
	    totalSpace *= 2;
	}
	newPtr = (char *) ckalloc(memoryp, (unsigned) totalSpace);
	strcpy(newPtr, iPtr->result);
	if (iPtr->appendResult != NULL) {
	    ckfree(memoryp, iPtr->appendResult);
	}
	iPtr->appendResult = newPtr;
	iPtr->appendAvl = totalSpace;
    } else if (iPtr->result != iPtr->appendResult) {
	strcpy(iPtr->appendResult, iPtr->result);
    }
    Hax_FreeResult((Hax_Interp *) iPtr);
    iPtr->result = iPtr->appendResult;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movq 0x280(%rdi), %r14
movq 0x118(%rdi), %rsi
cmpq %rsi, (%rdi)
je 0x11c95
cmpl $0x1f5, 0x120(%rbx)     # imm = 0x1F5
jl 0x11c87
leaq 0x57d5(%rip), %rdx      # 0x1743a
movq %r14, %rdi
movl $0x493, %ecx            # imm = 0x493
callq 0x4280
movq $0x0, 0x118(%rbx)
movl $0x0, 0x120(%rbx)
movq (%rbx), %rdi
callq 0x41d0
movl %eax, 0x124(%rbx)
addl 0x124(%rbx), %r15d
cmpl 0x120(%rbx), %r15d
jge 0x11cbb
movq (%rbx), %rsi
movq 0x118(%rbx), %rdi
cmpq %rdi, %rsi
je 0x11d20
callq 0x40f0
jmp 0x11d20
leal (%r15,%r15), %eax
cmpl $0x64, %r15d
movl $0xc8, %r15d
cmovgel %eax, %r15d
leaq 0x5766(%rip), %rdx      # 0x1743a
movq %r14, %rdi
movq %r15, %rsi
movl $0x4a2, %ecx            # imm = 0x4A2
callq 0x44c0
movq %rax, %r12
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x40f0
movq 0x118(%rbx), %rsi
testq %rsi, %rsi
je 0x11d12
leaq 0x5735(%rip), %rdx      # 0x1743a
movq %r14, %rdi
movl $0x4a5, %ecx            # imm = 0x4A5
callq 0x4280
movq %r12, 0x118(%rbx)
movl %r15d, 0x120(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x11d60
cmpq 0xa270(%rip), %rax      # 0x1bfa0
je 0x11d39
movq (%rbx), %rdi
callq *%rax
jmp 0x11d58
movq %rbx, %rdi
callq 0x4540
movq (%rbx), %rsi
leaq 0x56ef(%rip), %rdx      # 0x1743a
movq %rax, %rdi
movl $0x4ac, %ecx            # imm = 0x4AC
callq 0x4280
movq $0x0, 0x8(%rbx)
movq 0x118(%rbx), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x4110
incl %eax
movq (%rbx), %rcx
cmpq 0x118(%rbx), %rcx
jne 0x11db1
movl 0x124(%rbx), %ecx
addl %eax, %ecx
cmpl 0x120(%rbx), %ecx
jl 0x11dc1
addl 0x124(%rbx), %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x11c31
movl 0x124(%rbx), %eax
movslq %eax, %rcx
movq 0x118(%rbx), %rsi
addq %rcx, %rsi
testl %ebp, %ebp
setne %dl
testl %ecx, %ecx
sete %cl
orb %dl, %cl
jne 0x11df0
incl %eax
movl %eax, 0x124(%rbx)
movb $0x20, (%rsi)
incq %rsi
movl 0xc(%rsp), %edx
movq %r14, %rdi
callq 0x4170
addl %eax, 0x124(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x11e6c
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
movl $0x5, %r8d
leaq 0x34cc(%rip), %r14      # 0x15365
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x11eb2
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x11ec0
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rcx
testq %rcx, %rcx
je 0x11edd
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x40e0
movl $0x7, %r8d
jmp 0x11e99
orb $0x8, 0x1a0(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4640
movsbq (%r14), %rcx
cmpq $0x2d, %rcx
je 0x11f5d
movq (%rax), %rax
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
jne 0x11f5d
movq %r14, %rdi
callq 0x41d0
leaq 0x3233(%rip), %rsi      # 0x1515c
movq %r14, %rdi
movq %rax, %rdx
callq 0x40c0
testl %eax, %eax
je 0x11f87
leaq 0x5525(%rip), %rsi      # 0x17464
leaq 0x552a(%rip), %rcx      # 0x17470
movq %r15, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
jmp 0x11f90
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x44b0
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x11f90
xorl %eax, %eax
cmpq $0x0, (%rbx)
jns 0x11f90
movq $0x0, (%rbx)
jmp 0x11f90
movq $0x40000000, (%rbx)     # imm = 0x40000000
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1(%rsi), %r12
movzbl -0x1(%r12), %eax
testl %eax, %eax
je 0x12208
cmpl $0x28, %eax
je 0x121b3
incq %r12
jmp 0x1219f
leaq -0x2(%r12), %r13
cmpb $0x0, 0x2(%r13)
leaq 0x1(%r13), %r13
jne 0x121b8
movb (%r13), %bpl
cmpb $0x29, %bpl
jne 0x121f3
xorl %eax, %eax
movb %al, -0x1(%r12)
movb %al, (%r13)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x44a0
movb $0x28, -0x1(%r12)
movb $0x29, (%r13)
cmpb $0x29, %bpl
jne 0x12208
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x44a0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
callq 0x42d0
leaq 0x5386(%rip), %rsi      # 0x1777f
leaq 0x2eae(%rip), %rcx      # 0x152ae
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x4500
testq %r15, %r15
je 0x12436
leaq 0x4587(%rip), %rsi      # 0x169a6
leaq 0x4e0e(%rip), %rcx      # 0x17234
movq %r14, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
leaq 0x5349(%rip), %rsi      # 0x17786
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4500
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r8d
movq %rdx, %rcx
movq %rsi, %r15
leaq 0x1(%rsi), %r13
movzbl -0x1(%r13), %eax
testl %eax, %eax
je 0x1260b
cmpl $0x28, %eax
je 0x125ac
incq %r13
jmp 0x12599
leaq -0x2(%r13), %rbp
cmpb $0x0, 0x2(%rbp)
leaq 0x1(%rbp), %rbp
jne 0x125b0
movb (%rbp), %bl
cmpb $0x29, %bl
jne 0x125f7
xorl %eax, %eax
movb %al, -0x1(%r13)
movb %al, (%rbp)
movq %rdi, (%rsp)
movq (%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rcx, %r12
movl %r8d, %r14d
callq 0x40e0
movq (%rsp), %rdi
movq %r12, %rcx
movl %r14d, %r8d
movb $0x28, -0x1(%r13)
movb $0x29, (%rbp)
cmpb $0x29, %bl
jne 0x1260b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x40e0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
je 0x12ace
movq 0x280(%rdi), %r14
leaq 0x4a12(%rip), %r15      # 0x174bf
movq 0x30(%rsi), %rax
movq %rax, 0x18(%rbx)
movq %r14, %rdi
movq %r15, %rdx
movl $0x894, %ecx            # imm = 0x894
callq 0x4280
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
jne 0x12aad
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1(%rsi), %r12
movzbl -0x1(%r12), %eax
testl %eax, %eax
je 0x12b54
cmpl $0x28, %eax
je 0x12aff
incq %r12
jmp 0x12aeb
leaq -0x2(%r12), %r13
cmpb $0x0, 0x2(%r13)
leaq 0x1(%r13), %r13
jne 0x12b04
movb (%r13), %bpl
cmpb $0x29, %bpl
jne 0x12b3f
xorl %eax, %eax
movb %al, -0x1(%r12)
movb %al, (%r13)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x42a0
movb $0x28, -0x1(%r12)
movb $0x29, (%r13)
cmpb $0x29, %bpl
jne 0x12b54
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42a0
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxVar.c
// Function: DeleteArray
static void
DeleteArray(
    Interp *iPtr,			/* Interpreter containing array. */
    char *arrayName,			/* Name of array (used for trace
					 * callbacks). */
    Var *varPtr,			/* Pointer to variable structure. */
    int flags				/* Flags to pass to CallTraces:
					 * HAX_TRACE_UNSETS and sometimes
					 * HAX_INTERP_DESTROYED and/or
					 * HAX_GLOBAL_ONLY. */)
{
    Hax_Memoryp *memoryp = iPtr->memoryp;
    Hax_HashSearch search;
    Hax_HashEntry *hPtr;
    Var *elPtr;

    DeleteSearches((Hax_Interp *) iPtr, varPtr);
    for (hPtr = Hax_FirstHashEntry(varPtr->value.tablePtr, &search);
	    hPtr != NULL; hPtr = Hax_NextHashEntry(&search)) {
	elPtr = (Var *) Hax_GetHashValue(hPtr);
	if (elPtr->tracePtr != NULL) {
	    (void) CallTraces(iPtr, (Var *) NULL, hPtr, arrayName,
		    Hax_GetHashKey(varPtr->value.tablePtr, hPtr), flags);
	    while (elPtr->tracePtr != NULL) {
		VarTrace *tracePtr = elPtr->tracePtr;
		elPtr->tracePtr = tracePtr->nextPtr;
		ckfree(memoryp, (char *) tracePtr);
	    }
	}
	if (elPtr->flags & VAR_SEARCHES_POSSIBLE) {
	    Hax_Panic((char *) "DeleteArray found searches on array alement!");
	}
	ckfree(memoryp, (char *) elPtr);
    }
    Hax_DeleteHashTable((Hax_Interp *) iPtr, varPtr->value.tablePtr);
    ckfree(memoryp, (char *) varPtr->value.tablePtr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x280(%rdi), %rbx
movq %rdx, %rsi
callq 0x12a8e
movq 0x28(%r14), %rdi
leaq 0x10(%rsp), %rsi
callq 0x43d0
testq %rax, %rax
je 0x12ec9
leaq 0x4684(%rip), %r13      # 0x174bf
movq 0x18(%rax), %rbp
cmpq $0x0, 0x10(%rbp)
je 0x12e8f
movq 0x28(%r14), %rcx
leaq 0x20(%rax), %r8
cmpl $0x1, 0x3c(%rcx)
jne 0x12e57
movq (%r8), %r8
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r12, %rcx
movl 0xc(%rsp), %r9d
callq 0x12455
movq 0x10(%rbp), %rsi
testq %rsi, %rsi
je 0x12e8f
movq 0x18(%rsi), %rax
movq %rax, 0x10(%rbp)
movq %rbx, %rdi
movq %r13, %rdx
movl $0x8c7, %ecx            # imm = 0x8C7
callq 0x4280
jmp 0x12e6c
testb $0x40, 0x20(%rbp)
je 0x12ea3
leaq 0x48b6(%rip), %rdi      # 0x17752
xorl %eax, %eax
callq 0x4140
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movl $0x8cd, %ecx            # imm = 0x8CD
callq 0x4280
leaq 0x10(%rsp), %rdi
callq 0x4380
testq %rax, %rax
jne 0x12e3b
movq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0x4210
movq 0x28(%r14), %rsi
leaq 0x45df(%rip), %rdx      # 0x174bf
movq %rbx, %rdi
movl $0x8d0, %ecx            # imm = 0x8D0
callq 0x4280
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r9
movq %rcx, %r8
movl %edx, %ecx
movq %rsi, %r15
leaq 0x1(%rsi), %r13
movzbl -0x1(%r13), %eax
testl %eax, %eax
je 0x12f9a
cmpl $0x28, %eax
je 0x12f2c
incq %r13
jmp 0x12f19
leaq -0x2(%r13), %rbx
cmpb $0x0, 0x2(%rbx)
leaq 0x1(%rbx), %rbx
jne 0x12f30
movb (%rbx), %r14b
cmpb $0x29, %r14b
jne 0x12f85
xorl %eax, %eax
movb %al, -0x1(%r13)
movb %al, (%rbx)
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
movl %ecx, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq %r8, %r12
movq %r9, %rbp
callq 0x41f0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %ecx
movq %r12, %r8
movq %rbp, %r9
movb $0x28, -0x1(%r13)
movb $0x29, (%rbx)
cmpb $0x29, %r14b
jne 0x12f9a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rsi
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x41f0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r9
movq %rcx, %r8
movl %edx, %ecx
movq %rsi, %r15
leaq 0x1(%rsi), %r13
movzbl -0x1(%r13), %eax
testl %eax, %eax
je 0x133dd
cmpl $0x28, %eax
je 0x1336f
incq %r13
jmp 0x1335c
leaq -0x2(%r13), %rbx
cmpb $0x0, 0x2(%rbx)
leaq 0x1(%rbx), %rbx
jne 0x13373
movb (%rbx), %r14b
cmpb $0x29, %r14b
jne 0x133c8
xorl %eax, %eax
movb %al, -0x1(%r13)
movb %al, (%rbx)
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
movl %ecx, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq %r8, %r12
movq %r9, %rbp
callq 0x4330
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %ecx
movq %r12, %r8
movq %rbp, %r9
movb $0x28, -0x1(%r13)
movb $0x29, (%rbx)
cmpb $0x29, %r14b
jne 0x133dd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rsi
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4330
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rsi, %rbx
cmpl $0x3, %edx
je 0x134ce
cmpl $0x2, %edx
jne 0x134ef
movq 0x8(%rcx), %rsi
movq %rbx, %rdi
movl $0x200, %edx            # imm = 0x200
callq 0x4550
jmp 0x134e3
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rbx, %rdi
movl $0x200, %ecx            # imm = 0x200
callq 0x4450
testq %rax, %rax
je 0x1350d
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x13512
movq (%rcx), %rdx
leaq 0x237b(%rip), %rsi      # 0x15874
leaq 0x3fc8(%rip), %rcx      # 0x174c8
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x2, %edx
jge 0x1354c
movq (%r14), %rdx
leaq 0x2343(%rip), %rsi      # 0x15874
leaq 0x3fa5(%rip), %rcx      # 0x174dd
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
jmp 0x13574
movl %edx, %r15d
movl $0x1, %r12d
movq (%r14,%r12,8), %rsi
movq %rbx, %rdi
movl $0x200, %edx            # imm = 0x200
callq 0x4270
testl %eax, %eax
jne 0x13545
incq %r12
cmpq %r12, %r15
jne 0x13555
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x3, %edx
jge 0x135b8
movq (%r14), %rdx
leaq 0x22d7(%rip), %rsi      # 0x15874
leaq 0x3f51(%rip), %rcx      # 0x174f5
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movl $0x1, %eax
jmp 0x135e8
movl %edx, %r15d
movl $0x2, %r12d
movq 0x8(%r14), %rsi
movq (%r14,%r12,8), %rdx
movq %rbx, %rdi
movl $0x202, %ecx            # imm = 0x202
callq 0x4450
testq %rax, %rax
je 0x135b1
incq %r12
cmpq %r12, %r15
jne 0x135c1
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxVar.c
// Function: ParseSearchId
static ArraySearch *
ParseSearchId(
    Hax_Interp *interp,		/* Interpreter containing variable. */
    Var *varPtr,		/* Array variable search is for. */
    char *varName,		/* Name of array variable that search is
				 * supposed to be for. */
    char *string		/* String containing id of search.  Must have
				 * form "search-num-var" where "num" is a
				 * decimal number and "var" is a variable
				 * name. */)
{
    char *end;
    int id;
    ArraySearch *searchPtr;

    /*
     * Parse the id into the three parts separated by dashes.
     */

    if ((string[0] != 's') || (string[1] != '-')) {
	syntax:
	Hax_AppendResult(interp, "illegal search identifier \"", string,
		"\"", (char *) NULL);
	return NULL;
    }
    id = Strtoul(NULL, string+2, &end, 10);
    if ((end == (string+2)) || (*end != '-')) {
	goto syntax;
    }
    if (strcmp(end+1, varName) != 0) {
	Hax_AppendResult(interp, "search identifier \"", string,
		"\" isn't for variable \"", varName, "\"", (char *) NULL);
	return NULL;
    }

    /*
     * Search through the list of active searches on the interpreter
     * to see if the desired one exists.
     */

    for (searchPtr = varPtr->searchPtr; searchPtr != NULL;
	    searchPtr = searchPtr->nextPtr) {
	if (searchPtr->id == id) {
	    return searchPtr;
	}
    }
    Hax_AppendResult(interp, "couldn't find search \"", string, "\"",
	    (char *) NULL);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdi, %r14
cmpb $0x73, (%rcx)
jne 0x13d31
cmpb $0x2d, 0x1(%rbx)
jne 0x13d31
movq %rdx, %r12
movq %rsi, %r15
leaq 0x2(%rbx), %rbp
leaq 0x10(%rsp), %r13
xorl %edi, %edi
movq %rbp, %rsi
movq %r13, %rdx
movl $0xa, %ecx
callq 0x4350
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x13d31
cmpb $0x2d, (%rdi)
jne 0x13d31
movq %rax, %r13
incq %rdi
movq %r12, %rsi
callq 0x4310
testl %eax, %eax
je 0x13d64
movq $0x0, (%rsp)
leaq 0x3a02(%rip), %rsi      # 0x17710
leaq 0x3a0f(%rip), %rcx      # 0x17724
leaq 0x1593(%rip), %r9       # 0x152af
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %r8
xorl %eax, %eax
callq 0x4500
jmp 0x13d52
leaq 0x39d0(%rip), %rsi      # 0x17708
leaq 0x1570(%rip), %rcx      # 0x152af
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4500
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r15), %r15
testq %r15, %r15
je 0x13d7e
movq %r13, %rax
cmpl %eax, (%r15)
je 0x13d52
movq 0x30(%r15), %r15
testq %r15, %r15
jne 0x13d70
leaq 0x39b6(%rip), %rsi      # 0x1773b
jmp 0x13d38
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x142f3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x7cd6(%rip), %rbx      # 0x1bff0
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x4530
movq (%rbx), %rdi
callq 0x4420
callq 0x4070
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x4080
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x4370
movq %rax, %r15
testq %rbx, %rbx
je 0x143b3
movl (%r14), %esi
cmpq $0x22, %rsi
ja 0x1439d
movabsq $0x400400001, %rax      # imm = 0x400400001
btq %rsi, %rax
jb 0x143ad
leaq 0x33e6(%rip), %rdi      # 0x1778a
xorl %eax, %eax
callq 0x4140
xorl %esi, %esi
movl %esi, 0x278(%rbx)
movl %r13d, (%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxStrtol.c
// Function: Strtoll
long long int
Strtoll(
    Interp *iPtr,
    const char *nptr,
    char **endptr,
    int base)
{
    long long int result;
    int saved_errno;

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

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x4080
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x4320
movq %rax, %r15
testq %rbx, %rbx
je 0x14433
movl (%r14), %esi
cmpq $0x22, %rsi
ja 0x1441d
movabsq $0x400400001, %rax      # imm = 0x400400001
btq %rsi, %rax
jb 0x1442d
leaq 0x3366(%rip), %rdi      # 0x1778a
xorl %eax, %eax
callq 0x4140
xorl %esi, %esi
movl %esi, 0x278(%rbx)
movl %r13d, (%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x4080
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x4560
movq %rax, %r15
testq %rbx, %rbx
je 0x144b3
movl (%r14), %esi
cmpq $0x22, %rsi
ja 0x1449d
movabsq $0x400400001, %rax      # imm = 0x400400001
btq %rsi, %rax
jb 0x144ad
leaq 0x32e6(%rip), %rdi      # 0x1778a
xorl %eax, %eax
callq 0x4140
xorl %esi, %esi
movl %esi, 0x278(%rbx)
movl %r13d, (%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x4080
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x4150
testq %rbx, %rbx
je 0x14538
movl (%r14), %esi
cmpq $0x22, %rsi
ja 0x14516
movabsq $0x400400001, %rax      # imm = 0x400400001
btq %rsi, %rax
jb 0x14532
leaq 0x326d(%rip), %rdi      # 0x1778a
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x4140
movsd 0x8(%rsp), %xmm0
xorl %esi, %esi
movl %esi, 0x278(%rbx)
movl %ebp, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
callq 0x51e0
testq %rax, %rax
je 0x5e49
popq %rcx
retq
callq 0x5570
movl (%rax), %edi
callq 0x5430
leaq 0x8713(%rip), %rdi      # 0xe56f
movq %rax, %rsi
xorl %eax, %eax
callq 0x5e66
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/st.c
// Function: die
void die(const char *errstr, ...) {
  va_list ap;

  va_start(ap, errstr);
  vfprintf(stderr, errstr, ap);
  va_end(ap);
  exit(1);
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x5ec4
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0xf105(%rip), %rax      # 0x14ff0
movq (%rax), %rdi
movq %r10, %rsi
callq 0x52d0
movl $0x1, %edi
callq 0x5180
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/st.c
// Function: selstart
void selstart(int col, int row, int snap) {
  selclear();
  sel.mode = SEL_EMPTY;
  sel.type = SEL_REGULAR;
  sel.alt = IS_SET(MODE_ALTSCREEN);
  sel.snap = snap;
  sel.oe.x = sel.ob.x = col;
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  sel.oe.y = sel.ob.y = row;
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
  selnormalize();

  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  if (sel.snap != 0)
    sel.mode = SEL_READY;
  tsetdirt(sel.nb.y, sel.ne.y);
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movl %esi, %ebx
movl %edi, %ebp
cmpl $-0x1, 0xf7b2(%rip)     # 0x157ac
je 0x6021
movl $0x0, 0xf78a(%rip)      # 0x15790
movl $0xffffffff, 0xf79c(%rip) # imm = 0xFFFFFFFF
movl 0xf78a(%rip), %edi      # 0x157a0
movl 0xf78c(%rip), %esi      # 0x157a8
callq 0x61bb
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0xf75e(%rip)      # 0x15790
movl 0xf7d4(%rip), %eax      # 0x1580c
shrl $0x2, %eax
andl $0x1, %eax
movl %eax, 0xf778(%rip)      # 0x157bc
movl %r14d, 0xf74d(%rip)     # 0x15798
movl %ebp, 0xf75b(%rip)      # 0x157ac
movl %ebp, 0xf75d(%rip)      # 0x157b4
movl %ebx, 0xf753(%rip)      # 0x157b0
movl %ebx, 0xf755(%rip)      # 0x157b8
callq 0x60bf
cmpl $0x0, 0xf729(%rip)      # 0x15798
je 0x607b
movl $0x2, 0xf715(%rip)      # 0x15790
movl 0xf71f(%rip), %edi      # 0x157a0
movl 0xf721(%rip), %esi      # 0x157a8
popq %rbx
popq %r14
popq %rbp
jmp 0x61bb
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/st.c
// Function: tsetdirt
void tsetdirt(int top, int bot) {
  int i;

  LIMIT(top, 0, term.row - 1);
  LIMIT(bot, 0, term.row - 1);

  for (i = top; i <= bot; i++)
    term.dirty[i] = 1;
}

// Assembly:
xorl %eax, %eax
movl $0x0, %ecx
testl %edi, %edi
js 0x61d3
movl 0xf5f4(%rip), %ecx      # 0x157c0
decl %ecx
cmpl %edi, %ecx
cmovgel %edi, %ecx
testl %esi, %esi
js 0x61e4
movl 0xf5e3(%rip), %eax      # 0x157c0
decl %eax
cmpl %esi, %eax
cmovgel %esi, %eax
cmpl %eax, %ecx
jg 0x620a
movslq %ecx, %rdx
shlq $0x2, %rdx
addq 0xf5e2(%rip), %rdx      # 0x157d8
subl %ecx, %eax
incl %eax
xorl %ecx, %ecx
movl $0x1, (%rdx,%rcx,4)
incq %rcx
cmpl %ecx, %eax
jne 0x61fc
retq
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/st.c
// Function: selextend
void selextend(int col, int row, int type, int done) {
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  int oldey, oldex, oldsby, oldsey, oldtype;
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse

  if (sel.mode == SEL_IDLE)
    return;
  if (done && sel.mode == SEL_EMPTY) {
    selclear();
    return;
  }

  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  oldey = sel.oe.y;
  oldex = sel.oe.x;
  oldsby = sel.nb.y;
  oldsey = sel.ne.y;
  oldtype = sel.type;
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse

  sel.oe.x = col;
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  sel.oe.y = row;
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
  selnormalize();
  sel.type = type;

  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  if (oldey != sel.oe.y || oldex != sel.oe.x || oldtype != sel.type ||
      sel.mode == SEL_EMPTY)
    tsetdirt(MIN(sel.nb.y, oldsby), MAX(sel.ne.y, oldsey));
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse

  sel.mode = done ? SEL_IDLE : SEL_READY;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0xf574(%rip), %eax      # 0x15790
testl %eax, %eax
je 0x6309
movl %ecx, %ebx
testl %ecx, %ecx
sete %cl
cmpl $0x1, %eax
setne %al
orb %cl, %al
jne 0x6275
cmpl $-0x1, 0xf570(%rip)     # 0x157ac
je 0x6309
movl $0x0, 0xf544(%rip)      # 0x15790
movl $0xffffffff, 0xf556(%rip) # imm = 0xFFFFFFFF
movl 0xf544(%rip), %edi      # 0x157a0
movl 0xf546(%rip), %esi      # 0x157a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x61bb
movl %edx, %ebp
movl 0xf53a(%rip), %r12d     # 0x157b8
movl 0xf52f(%rip), %r13d     # 0x157b4
movl 0xf514(%rip), %r14d     # 0x157a0
movl 0xf515(%rip), %r15d     # 0x157a8
movl 0xf4fb(%rip), %eax      # 0x15794
movl %eax, 0x4(%rsp)
movl %edi, 0xf511(%rip)      # 0x157b4
movl %esi, 0xf50f(%rip)      # 0x157b8
callq 0x60bf
movl %ebp, 0xf4e0(%rip)      # 0x15794
cmpl 0xf4fd(%rip), %r12d     # 0x157b8
jne 0x62d5
cmpl 0xf4f0(%rip), %r13d     # 0x157b4
jne 0x62d5
cmpl %ebp, 0x4(%rsp)
jne 0x62d5
cmpl $0x1, 0xf4bd(%rip)      # 0x15790
jne 0x62fa
movl 0xf4c5(%rip), %eax      # 0x157a0
cmpl %r14d, %eax
cmovll %eax, %r14d
movl 0xf4c0(%rip), %eax      # 0x157a8
cmpl %r15d, %eax
cmovgl %eax, %r15d
movl %r14d, %edi
movl %r15d, %esi
callq 0x61bb
xorl %eax, %eax
testl %ebx, %ebx
sete %al
addl %eax, %eax
movl %eax, 0xf487(%rip)      # 0x15790
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/st.c
// Function: selected
int selected(int x, int y) {
  if (sel.mode == SEL_EMPTY || sel.ob.x == -1 ||
      sel.alt != IS_SET(MODE_ALTSCREEN))
    return 0;

  if (sel.type == SEL_RECTANGULAR)
    return BETWEEN(y, sel.nb.y, sel.ne.y) && BETWEEN(x, sel.nb.x, sel.ne.x);

  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  return BETWEEN(y, sel.nb.y, sel.ne.y) && (y != sel.nb.y || x >= sel.nb.x) &&
    (y != sel.ne.y || x <= sel.ne.x);
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
}

// Assembly:
xorl %eax, %eax
cmpl $0x1, 0xf46f(%rip)      # 0x15790
je 0x638e
cmpl $-0x1, 0xf482(%rip)     # 0x157ac
je 0x638e
movl 0xf48a(%rip), %eax      # 0x157bc
btl $0x2, 0xf4d2(%rip)      # 0x1580c
sbbl $0x0, %eax
jne 0x638c
movl 0xf45b(%rip), %ecx      # 0x157a0
cmpl %esi, %ecx
setg %r8b
movl 0xf457(%rip), %eax      # 0x157a8
cmpl %esi, %eax
setl %dl
orb %r8b, %dl
cmpl $0x2, 0xf434(%rip)      # 0x15794
jne 0x637c
testb %dl, %dl
jne 0x638c
cmpl %edi, 0xf430(%rip)      # 0x1579c
setle %cl
cmpl %edi, 0xf42f(%rip)      # 0x157a4
setge %al
andb %cl, %al
jmp 0x638e
testb %dl, %dl
jne 0x638c
cmpl %esi, %ecx
jne 0x6392
cmpl %edi, 0xf412(%rip)      # 0x1579c
jle 0x6392
xorl %eax, %eax
movzbl %al, %eax
retq
cmpl %esi, %eax
setne %cl
cmpl %edi, 0xf407(%rip)      # 0x157a4
setge %al
orb %cl, %al
jmp 0x638e
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/st.c
// Function: tlinelen
int tlinelen(int y) {
  int i = term.col;

  // >>>>>>>>>>>>>>>>>>>> scrollback
  // ==================== scrollback
  if (term.line[y][i - 1].mode & ATTR_WRAP)
  // ==================== scrollback
  // <<<<<<<<<<<<<<<<<<<< scrollback
    return i;

  // >>>>>>>>>>>>>>>>>>>> scrollback
  // ==================== scrollback
  while (i > 0 && term.line[y][i - 1].u == ' ')
  // ==================== scrollback
  // <<<<<<<<<<<<<<<<<<<< scrollback
    --i;

  return i;
}

// Assembly:
movslq 0xf2bb(%rip), %rax      # 0x157c4
movq 0xf2b8(%rip), %rcx      # 0x157c8
movslq %edi, %rdx
movq (%rcx,%rdx,8), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
testb $0x1, -0xb(%rcx,%rdx)
jne 0x6545
testl %eax, %eax
jle 0x6545
addq $-0x10, %rcx
movl %eax, %edx
shlq $0x4, %rdx
cmpl $0x20, (%rcx,%rdx)
jne 0x6545
leal -0x1(%rax), %edx
cmpl $0x1, %eax
movl %edx, %eax
jg 0x652d
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/st.c
// Function: ttyread
size_t ttyread(void) {
  static char buf[BUFSIZ];
  static int buflen = 0;
  int ret, written;

  /* append read bytes to unprocessed bytes */
  // >>>>>>>>>>>>>>>>>>>> sync
  // ==================== sync
  ret = read(cmdfd, buf + buflen, LEN(buf) - buflen);
  // ==================== sync
  // <<<<<<<<<<<<<<<<<<<< sync

  switch (ret) {
  case 0:
    exit(0);
  case -1:
    die("couldn't read from shell: %s\n", strerror(errno));
  default:
    // >>>>>>>>>>>>>>>>>>>> sync
    // ==================== sync
    buflen += ret;
    // ==================== sync
    // <<<<<<<<<<<<<<<<<<<< sync
    written = twrite(buf, buflen, 0);
    buflen -= written;
    /* keep any incomplete UTF-8 byte sequence for the next call */
    if (buflen > 0)
      memmove(buf, buf + written, buflen);
    return ret;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0xedfa(%rip), %edi      # 0x15830
movslq 0x10e03(%rip), %rax     # 0x17840
leaq 0xedfc(%rip), %rsi      # 0x15840
addq %rax, %rsi
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x51d0
movq %rax, %rbx
cmpl $-0x1, %ebx
je 0x6aaa
testl %ebx, %ebx
je 0x6ac7
movl 0x10dda(%rip), %esi     # 0x17840
addl %ebx, %esi
movl %esi, 0x10dd2(%rip)     # 0x17840
leaq 0xedcb(%rip), %r14      # 0x15840
movq %r14, %rdi
xorl %edx, %edx
callq 0x6ace
movl 0x10dbb(%rip), %ecx     # 0x17840
subl %eax, %ecx
movl %ecx, 0x10db3(%rip)     # 0x17840
jle 0x6a9f
movslq %eax, %rsi
addq %r14, %rsi
movl %ecx, %edx
movq %r14, %rdi
callq 0x54e0
movslq %ebx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5570
movl (%rax), %edi
callq 0x5430
leaq 0x7b4a(%rip), %rdi      # 0xe607
movq %rax, %rsi
xorl %eax, %eax
callq 0x5e66
xorl %edi, %edi
callq 0x5180
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/st.c
// Function: twrite
int twrite(const char *buf, int buflen, int show_ctrl) {
  int charsize;
  Rune u;
  int n;

  // >>>>>>>>>>>>>>>>>>>> sync
  // ==================== sync
  // ==================== sync
  // <<<<<<<<<<<<<<<<<<<< sync

  for (n = 0; n < buflen; n += charsize) {
    if (IS_SET(MODE_UTF8)) {
      /* process a complete utf8 char */
      charsize = utf8decode(buf + n, &u, buflen - n);
      if (charsize == 0)
        break;
    } else {
      u = buf[n] & 0xFF;
      charsize = 1;
    }
    // >>>>>>>>>>>>>>>>>>>> sync
    // ==================== sync
    // ==================== sync
    // <<<<<<<<<<<<<<<<<<<< sync
    if (show_ctrl && ISCONTROL(u)) {
      if (u & 0x80) {
        u &= 0x7f;
        tputc('^');
        tputc('[');
      } else if (u != '\n' && u != '\r' && u != '\t') {
        u ^= 0x40;
        tputc('^');
      }
    }
    tputc(u);
  }
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x6bab
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0x4(%rsp), %r12
movslq %ebx, %rdi
addq %r15, %rdi
testb $0x40, 0xed0f(%rip)     # 0x1580c
jne 0x6b0e
movzbl (%rdi), %eax
movl %eax, 0x4(%rsp)
movl $0x1, %r13d
jmp 0x6b2a
movl %r14d, %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r12, %rsi
callq 0x7d1b
movq %rax, %r13
testl %r13d, %r13d
je 0x6bad
testl %ebp, %ebp
je 0x6b94
movl 0x4(%rsp), %eax
cmpl $0x20, %eax
setae %cl
cmpl $0x7f, %eax
setne %dl
movl %eax, %esi
andl $-0x20, %esi
cmpl $0x80, %esi
setne %sil
andb %dl, %sil
testb %cl, %sil
jne 0x6b94
cmpl $0x80, %eax
jae 0x6b79
cmpl $0xd, %eax
ja 0x6b6b
movl $0x2600, %ecx           # imm = 0x2600
btl %eax, %ecx
jb 0x6b94
xorl $0x40, %eax
movl %eax, 0x4(%rsp)
movl $0x5e, %edi
jmp 0x6b8f
andl $0x7f, %eax
movl %eax, 0x4(%rsp)
movl $0x5e, %edi
callq 0x7e3b
movl $0x5b, %edi
callq 0x7e3b
movl 0x4(%rsp), %edi
callq 0x7e3b
addl %r13d, %ebx
cmpl %r14d, %ebx
jl 0x6af0
jmp 0x6bad
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq