LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
movq 0x118(%rbx), %rsi
movl 0x124(%rbx), %ecx
addl %ecx, %eax
incl %eax
cmpq %rsi, (%rbx)
jne 0x10895
cmpl 0x120(%rbx), %eax
jl 0x108ac
movq %rbx, %rdi
movl %eax, %esi
callq 0x10706
movq 0x118(%rbx), %rsi
movl 0x124(%rbx), %ecx
movslq %ecx, %rax
addq %rax, %rsi
testl %ebp, %ebp
setne %dl
testl %eax, %eax
sete %al
orb %dl, %al
jne 0x108ce
incl %ecx
movl %ecx, 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_O2/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
pushq %r14
pushq %rbx
subq $0xd0, %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 0x1094b
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)
pushq $0x5
popq %r8
leaq 0x29ef(%rip), %r14      # 0x13365
pushq $0x7
popq %rbp
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x10992
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x109a0
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rcx
testq %rcx, %rcx
je 0x109ba
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x40e0
movl %ebp, %r8d
jmp 0x10979
orb $0x8, 0x1a0(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4660
movsbq (%r14), %rcx
cmpq $0x2d, %rcx
je 0x10a36
movq (%rax), %rax
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
jne 0x10a36
movq %r14, %rdi
callq 0x41d0
leaq 0x2755(%rip), %rsi      # 0x1315c
movq %r14, %rdi
movq %rax, %rdx
callq 0x40c0
testl %eax, %eax
je 0x10a5b
leaq 0x471b(%rip), %rsi      # 0x15138
leaq 0x4720(%rip), %rcx      # 0x15144
movq %r15, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
jmp 0x10a48
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x44d0
testl %eax, %eax
je 0x10a4d
pushq $0x1
popq %rax
jmp 0x10a64
xorl %eax, %eax
cmpq $0x0, (%rbx)
jns 0x10a64
andq $0x0, (%rbx)
jmp 0x10a64
movq $0x40000000, (%rbx)     # imm = 0x40000000
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4634(%rip), %rsi      # 0x15453
leaq 0x2488(%rip), %rcx      # 0x132ae
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x4520
testq %r15, %r15
je 0x10e5c
leaq 0x3941(%rip), %rsi      # 0x14786
leaq 0x40bc(%rip), %rcx      # 0x14f08
movq %r14, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
leaq 0x45f7(%rip), %rsi      # 0x1545a
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4520
// File: /workspace/github_c_makefile_star2_O2/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 0x280(%rdi), %r14
leaq 0x3dc2(%rip), %r15      # 0x15193
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x113f4
movq 0x30(%rsi), %rax
movq %rax, 0x18(%rbx)
movq %r14, %rdi
movq %r15, %rdx
movl $0x894, %ecx            # imm = 0x894
callq 0x4280
jmp 0x113d1
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x113bb
movq 0x28(%r14), %rdi
leaq 0x10(%rsp), %rsi
callq 0x43f0
leaq 0x3a8c(%rip), %r13      # 0x15193
testq %rax, %rax
je 0x1179a
movq 0x18(%rax), %rbp
cmpq $0x0, 0x10(%rbp)
je 0x11764
movq 0x28(%r14), %rcx
leaq 0x20(%rax), %r8
cmpl $0x1, 0x3c(%rcx)
jne 0x1172c
movq (%r8), %r8
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r12, %rcx
movl 0xc(%rsp), %r9d
callq 0x10e7b
movq 0x10(%rbp), %rsi
testq %rsi, %rsi
je 0x11764
movq 0x18(%rsi), %rax
movq %rax, 0x10(%rbp)
movq %rbx, %rdi
movq %r13, %rdx
movl $0x8c7, %ecx            # imm = 0x8C7
callq 0x4280
jmp 0x11741
testb $0x40, 0x20(%rbp)
je 0x11778
leaq 0x3cb5(%rip), %rdi      # 0x15426
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 0x43a0
jmp 0x11707
movq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0x4210
movq 0x28(%r14), %rsi
leaq 0x39e2(%rip), %rdx      # 0x15193
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_O2/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 0x11c69
cmpl $0x2, %edx
jne 0x11c8a
movq 0x8(%rcx), %rsi
movq %rbx, %rdi
movl $0x200, %edx            # imm = 0x200
callq 0x4570
jmp 0x11c7e
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rbx, %rdi
movl $0x200, %ecx            # imm = 0x200
callq 0x4470
testq %rax, %rax
je 0x11ca8
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x11cab
movq (%rcx), %rdx
leaq 0x1bcc(%rip), %rsi      # 0x13860
leaq 0x3501(%rip), %rcx      # 0x1519c
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x2, %edx
jge 0x11ce3
movq (%r14), %rdx
leaq 0x1b96(%rip), %rsi      # 0x13860
leaq 0x34e0(%rip), %rcx      # 0x151b1
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rbp
jmp 0x11d0e
movl %edx, %r15d
pushq $0x1
popq %r12
pushq $0x1
popq %rbp
cmpq %r12, %r15
je 0x11d0c
movq (%r14,%r12,8), %rsi
movq %rbx, %rdi
movl $0x200, %edx            # imm = 0x200
callq 0x4270
incq %r12
testl %eax, %eax
je 0x11ced
jmp 0x11d0e
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x3, %edx
jge 0x11d4f
movq (%r14), %rdx
leaq 0x1b2a(%rip), %rsi      # 0x13860
leaq 0x348c(%rip), %rcx      # 0x151c9
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rbp
jmp 0x11d84
movl %edx, %r15d
pushq $0x2
popq %r12
xorl %eax, %eax
pushq $0x1
popq %rbp
cmpq %r12, %r15
je 0x11d7f
movq 0x8(%r14), %rsi
movq (%r14,%r12,8), %rdx
movq %rbx, %rdi
movl $0x202, %ecx            # imm = 0x202
callq 0x4470
incq %r12
testq %rax, %rax
jne 0x11d5b
jmp 0x11d84
movq %rax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %r15
cmpb $0x73, (%rcx)
jne 0x123eb
cmpb $0x2d, 0x1(%r14)
jne 0x123eb
movq %rdx, %r12
movq %rsi, %rbx
leaq 0x2(%r14), %rbp
leaq 0x10(%rsp), %r13
pushq $0xa
popq %rcx
xorl %edi, %edi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x4370
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x123eb
cmpb $0x2d, (%rdi)
jne 0x123eb
movq %rax, %r13
incq %rdi
movq %r12, %rsi
callq 0x4330
testl %eax, %eax
je 0x1241d
andq $0x0, (%rsp)
leaq 0x301b(%rip), %rsi      # 0x153e4
leaq 0x3028(%rip), %rcx      # 0x153f8
leaq 0xed8(%rip), %r9        # 0x132af
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %r8
xorl %eax, %eax
callq 0x4520
jmp 0x1240b
leaq 0x2fea(%rip), %rsi      # 0x153dc
leaq 0xeb6(%rip), %rcx       # 0x132af
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x18, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x12434
cmpl %r13d, (%rbx)
je 0x1240b
addq $0x30, %rbx
jmp 0x12421
leaq 0x2fd4(%rip), %rsi      # 0x1540f
jmp 0x123f2
// File: /workspace/github_c_makefile_star2_O2/haxlang[P]hax/haxVar.c
// Function: Hax_GlobalCmd
int
Hax_GlobalCmd(
    ClientData dummy,			/* Not used. */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    Var *varPtr, *gVarPtr;
    Interp *iPtr = (Interp *) interp;
    Hax_HashEntry *hPtr, *hPtr2;
    int newPtr;

    if (argc < 2) {
	Hax_AppendResult((Hax_Interp *) iPtr, "wrong # args: should be \"",
		argv[0], " varName ?varName ...?\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (iPtr->varFramePtr == NULL) {
	return HAX_OK;
    }

    for (argc--, argv++; argc > 0; argc--, argv++) {
	hPtr = Hax_CreateHashEntry(interp, &iPtr->globalTable, *argv, &newPtr);
	if (newPtr) {
	    gVarPtr = NewVar(interp, 0);
	    gVarPtr->flags |= VAR_UNDEFINED;
	    Hax_SetHashValue(hPtr, gVarPtr);
	} else {
	    gVarPtr = (Var *) Hax_GetHashValue(hPtr);
	}
	hPtr2 = Hax_CreateHashEntry(interp, &iPtr->varFramePtr->varTable, *argv,
		    &newPtr);
	if (!newPtr) {
	    Var *varPtr;
	    varPtr = (Var *) Hax_GetHashValue(hPtr2);
	    if (varPtr->flags & VAR_UPVAR) {
		continue;
	    } else {
		Hax_AppendResult((Hax_Interp *) iPtr, "variable \"", *argv,
		    "\" already exists", (char *) NULL);
		return HAX_ERROR;
	    }
	}
	varPtr = NewVar(interp, 0);
	varPtr->flags |= VAR_UPVAR;
	varPtr->value.upvarPtr = hPtr;
	gVarPtr->upvarUses++;
	Hax_SetHashValue(hPtr2, varPtr);
    }
    return HAX_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x1, %edx
jg 0x1247c
movq (%r14), %rdx
leaq 0x1400(%rip), %rsi      # 0x13860
leaq 0x2d4a(%rip), %rcx      # 0x151b1
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4520
pushq $0x1
popq %rax
jmp 0x1253d
cmpq $0x0, 0xc8(%rbx)
je 0x1253b
leaq 0x68(%rbx), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %r14
leaq 0x8(%rsp), %r13
cmpl $0x2, %edx
jl 0x1253b
movl %edx, 0xc(%rsp)
movq (%r14), %rdx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r13, %rcx
callq *0xb0(%rbx)
movq %rax, %rbp
cmpl $0x0, 0x8(%rsp)
je 0x124de
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11371
movq %rax, %r12
orb $0x4, 0x20(%rax)
movq %rax, 0x18(%rbp)
jmp 0x124e2
movq 0x18(%rbp), %r12
movq 0xc8(%rbx), %rsi
movq (%r14), %rdx
movq %rbx, %rdi
movq %r13, %r15
movq %r13, %rcx
callq *0x48(%rsi)
movq %rax, %r13
cmpl $0x0, 0x8(%rsp)
je 0x1251f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11371
orb $0x2, 0x20(%rax)
movq %rbp, 0x28(%rax)
incl 0x8(%r12)
movq %rax, 0x18(%r13)
jmp 0x12529
movq 0x18(%r13), %rax
testb $0x2, 0x20(%rax)
je 0x1254c
addq $0x8, %r14
movl 0xc(%rsp), %edx
decl %edx
movq %r15, %r13
jmp 0x1249c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdx
leaq 0x17c9(%rip), %rsi      # 0x13d1f
leaq 0x2dcd(%rip), %rcx      # 0x1532a
jmp 0x12467
// File: /workspace/github_c_makefile_star2_O2/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 0x128af
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 0x871a(%rip), %rbx      # 0x1aff0
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x4550
movq (%rbx), %rdi
callq 0x4440
callq 0x4070
nop
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x4390
movq %rax, %r15
testq %rbx, %rbx
je 0x1294b
movl (%r14), %edi
callq 0x12960
movl %eax, 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_O2/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
andl $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x4340
movq %rax, %r15
testq %rbx, %rbx
je 0x129d9
movl (%r14), %edi
callq 0x12960
movl %eax, 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_O2/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
andl $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x4580
movq %rax, %r15
testq %rbx, %rbx
je 0x12a35
movl (%r14), %edi
callq 0x12960
movl %eax, 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_O2/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
andl $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x4150
testq %rbx, %rbx
je 0x12a96
movl (%r14), %edi
movsd %xmm0, 0x8(%rsp)
callq 0x12960
movsd 0x8(%rsp), %xmm0
movl %eax, 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_O2/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 0x5a09
popq %rcx
retq
callq 0x5570
movl (%rax), %edi
callq 0x5430
leaq 0x7b53(%rip), %rdi      # 0xd56f
movq %rax, %rsi
xorl %eax, %eax
callq 0x5a26
// File: /workspace/github_c_makefile_star2_O2/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 0x5a84
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 0xe545(%rip), %rax      # 0x13ff0
movq (%rax), %rdi
movq %r10, %rsi
callq 0x52d0
pushq $0x1
popq %rdi
callq 0x5180
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
movl %esi, %ebp
movl %edi, %r14d
callq 0x5c66
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0xeb79(%rip)      # 0x14780
movl 0xebef(%rip), %eax      # 0x147fc
shrl $0x2, %eax
andl $0x1, %eax
movl %eax, 0xeb93(%rip)      # 0x147ac
movl %ebx, 0xeb69(%rip)      # 0x14788
movl %r14d, 0xeb76(%rip)     # 0x1479c
movl %r14d, 0xeb77(%rip)     # 0x147a4
movl %ebp, 0xeb6d(%rip)      # 0x147a0
movl %ebp, 0xeb6f(%rip)      # 0x147a8
callq 0x5c8f
cmpl $0x0, 0xeb43(%rip)      # 0x14788
je 0x5c51
movl $0x2, 0xeb2f(%rip)      # 0x14780
movl 0xeb39(%rip), %edi      # 0x14790
movl 0xeb3b(%rip), %esi      # 0x14798
popq %rbx
popq %r14
popq %rbp
jmp 0x5d87
// File: /workspace/github_c_makefile_star2_O2/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:
testl %edi, %edi
js 0x5d9c
movl 0xea1f(%rip), %eax      # 0x147b0
decl %eax
cmpl %edi, %eax
cmovgel %edi, %eax
cltq
jmp 0x5d9e
xorl %eax, %eax
testl %esi, %esi
js 0x5db4
movl 0xea08(%rip), %ecx      # 0x147b0
decl %ecx
cmpl %esi, %ecx
cmovgel %esi, %ecx
movslq %ecx, %rcx
jmp 0x5db6
xorl %ecx, %ecx
movq 0xea0b(%rip), %rdx      # 0x147c8
cmpq %rcx, %rax
jg 0x5dce
movl $0x1, (%rdx,%rax,4)
incq %rax
jmp 0x5dbd
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movl 0xe99f(%rip), %eax      # 0x14780
testl %eax, %eax
je 0x5ea2
movl %ecx, %ebx
testl %ecx, %ecx
sete %cl
cmpl $0x1, %eax
setne %al
orb %cl, %al
jne 0x5e0b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5c66
movl %edx, %ebp
movl 0xe97c(%rip), %r14d     # 0x14790
movl 0xe97d(%rip), %r15d     # 0x14798
movl 0xe962(%rip), %r12d     # 0x14784
movsd 0xe97a(%rip), %xmm0     # 0x147a4
movaps %xmm0, (%rsp)
movl %edi, 0xe970(%rip)      # 0x147a4
movl %esi, 0xe96e(%rip)      # 0x147a8
callq 0x5c8f
movl %ebp, 0xe93f(%rip)      # 0x14784
movq 0xe957(%rip), %xmm0     # 0x147a4
pcmpeqd (%rsp), %xmm0
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
movmskpd %xmm0, %eax
cmpl $0x3, %eax
jne 0x5e6e
cmpl %ebp, %r12d
jne 0x5e6e
cmpl $0x1, 0xe914(%rip)      # 0x14780
jne 0x5e93
movl 0xe91c(%rip), %eax      # 0x14790
cmpl %r14d, %eax
cmovll %eax, %r14d
movl 0xe917(%rip), %eax      # 0x14798
cmpl %r15d, %eax
cmovgl %eax, %r15d
movl %r14d, %edi
movl %r15d, %esi
callq 0x5d87
xorl %eax, %eax
testl %ebx, %ebx
sete %al
addl %eax, %eax
movl %eax, 0xe8de(%rip)      # 0x14780
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0xe8c8(%rip)      # 0x14780
je 0x5f25
cmpl $-0x1, 0xe8db(%rip)     # 0x1479c
je 0x5f25
movl 0xe8e3(%rip), %eax      # 0x147ac
btl $0x2, 0xe92b(%rip)      # 0x147fc
sbbl $0x0, %eax
jne 0x5f23
movl 0xe8b4(%rip), %ecx      # 0x14790
cmpl %esi, %ecx
setg %r8b
movl 0xe8b0(%rip), %eax      # 0x14798
cmpl %esi, %eax
setl %dl
orb %r8b, %dl
cmpl $0x2, 0xe88d(%rip)      # 0x14784
jne 0x5f13
testb %dl, %dl
jne 0x5f23
cmpl %edi, 0xe889(%rip)      # 0x1478c
setle %cl
cmpl %edi, 0xe888(%rip)      # 0x14794
setge %al
andb %cl, %al
jmp 0x5f25
testb %dl, %dl
jne 0x5f23
cmpl %esi, %ecx
jne 0x5f29
cmpl %edi, 0xe86b(%rip)      # 0x1478c
jle 0x5f29
xorl %eax, %eax
movzbl %al, %eax
retq
cmpl %esi, %eax
setne %cl
cmpl %edi, 0xe860(%rip)      # 0x14794
setge %al
orb %cl, %al
jmp 0x5f25
// File: /workspace/github_c_makefile_star2_O2/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 0xe72b(%rip), %rax      # 0x147b4
movq 0xe728(%rip), %rcx      # 0x147b8
movslq %edi, %rdx
movq (%rcx,%rdx,8), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
testb $0x1, -0xb(%rcx,%rdx)
jne 0x60c6
addq $-0x10, %rcx
movl %eax, %edx
sarl $0x1f, %edx
andl %eax, %edx
testl %eax, %eax
jle 0x60c4
movl %eax, %esi
shlq $0x4, %rsi
cmpl $0x20, (%rcx,%rsi)
jne 0x60c6
decl %eax
jmp 0x60b0
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe27f(%rip), %edi      # 0x14820
movslq 0x10288(%rip), %rax     # 0x16830
leaq 0xe281(%rip), %rsi      # 0x14830
addq %rax, %rsi
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x51d0
movq %rax, %rbx
cmpl $-0x1, %ebx
je 0x6615
testl %ebx, %ebx
je 0x6632
movl 0x1025f(%rip), %esi     # 0x16830
addl %ebx, %esi
movl %esi, 0x10257(%rip)     # 0x16830
leaq 0xe250(%rip), %r14      # 0x14830
movq %r14, %rdi
xorl %edx, %edx
callq 0x6639
movl 0x10240(%rip), %ecx     # 0x16830
subl %eax, %ecx
movl %ecx, 0x10238(%rip)     # 0x16830
jle 0x660a
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 0x6fdd(%rip), %rdi      # 0xd605
movq %rax, %rsi
xorl %eax, %eax
callq 0x5a26
xorl %edi, %edi
callq 0x5180
// File: /workspace/github_c_makefile_star2_O2/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
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
xorl %r14d, %r14d
movl %ebp, %eax
subl %r14d, %eax
jle 0x670a
movslq %r14d, %rdi
addq %r15, %rdi
testb $0x40, 0xe196(%rip)     # 0x147fc
jne 0x6679
movzbl (%rdi), %r13d
movl %r13d, 0x4(%rsp)
pushq $0x1
popq %rax
movl %eax, %r12d
jmp 0x6693
movslq %eax, %rdx
leaq 0x4(%rsp), %rsi
callq 0x772f
movq %rax, %r12
testl %r12d, %r12d
je 0x670a
movl 0x4(%rsp), %r13d
testl %ebx, %ebx
je 0x66fa
cmpl $0x20, %r13d
setae %al
cmpl $0x7f, %r13d
setne %cl
movl %r13d, %edx
andl $-0x20, %edx
cmpl $0x80, %edx
setne %dl
andb %cl, %dl
testb %al, %dl
jne 0x66fa
cmpl $0x80, %r13d
jae 0x66e1
cmpl $0xd, %r13d
ja 0x66d4
movl $0x2600, %eax           # imm = 0x2600
btl %r13d, %eax
jb 0x66fa
xorl $0x40, %r13d
movl %r13d, 0x4(%rsp)
pushq $0x5e
jmp 0x66f4
andl $0x7f, %r13d
movl %r13d, 0x4(%rsp)
pushq $0x5e
popq %rdi
callq 0x77e7
pushq $0x5b
popq %rdi
callq 0x77e7
movl %r13d, %edi
callq 0x77e7
addl %r12d, %r14d
jmp 0x664e
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jaimecgomezz[P]st/st.c
// Function: tattrset
int tattrset(int attr) {
  int i, j;

  for (i = 0; i < term.row - 1; i++) {
    for (j = 0; j < term.col - 1; j++) {
      if (term.line[i][j].mode & attr)
        return 1;
    }
  }

  return 0;
}

// Assembly:
pushq %rbx
movl 0xddd1(%rip), %ecx      # 0x147b0
movl 0xddcf(%rip), %edx      # 0x147b4
decl %edx
movq 0xddca(%rip), %rsi      # 0x147b8
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
cmpl $0x2, %ecx
movl $0x1, %r8d
cmovll %r8d, %ecx
decl %ecx
shlq $0x4, %rdx
addq $0x10, %rdx
xorl %r9d, %r9d
cmpq %rcx, %r9
je 0x6a3b
xorl %r10d, %r10d
leaq 0x10(%r10), %r11
cmpq %r11, %rdx
je 0x6a33
movq (%rsi,%r9,8), %rbx
movzwl 0x4(%rbx,%r10), %ebx
movq %r11, %r10
testl %edi, %ebx
je 0x6a17
jmp 0x6a38
incq %r9
jmp 0x6a0f
movl %r8d, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jaimecgomezz[P]st/st.c
// Function: tsetdirtattr
void tsetdirtattr(int attr) {
  int i, j;

  for (i = 0; i < term.row - 1; i++) {
    for (j = 0; j < term.col - 1; j++) {
      if (term.line[i][j].mode & attr) {
        tsetdirt(i, i);
        break;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl 0xdd67(%rip), %eax      # 0x147b0
xorl %r14d, %r14d
pushq $0x1
popq %rbp
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
cmpq %rcx, %r14
jge 0x6aaa
movl 0xdd54(%rip), %ecx      # 0x147b4
movq 0xdd51(%rip), %rdx      # 0x147b8
cmpl $0x2, %ecx
cmovll %ebp, %ecx
decl %ecx
shlq $0x4, %rcx
addq $0x10, %rcx
xorl %esi, %esi
leaq 0x10(%rsi), %rdi
cmpq %rdi, %rcx
je 0x6aa5
movq (%rdx,%r14,8), %r8
movzwl 0x4(%r8,%rsi), %r8d
movq %rdi, %rsi
testl %ebx, %r8d
je 0x6a79
movl %r14d, %edi
movl %r14d, %esi
callq 0x5d87
movl 0xdd0b(%rip), %eax      # 0x147b0
incq %r14
jmp 0x6a4f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jaimecgomezz[P]st/st.c
// Function: treset
void treset(void) {
  uint i;

  term.c = (TCursor){{.mode = ATTR_NULL, .fg = defaultfg, .bg = defaultbg},
                     .x = 0,
                     .y = 0,
                     .state = CURSOR_DEFAULT};

  memset(term.tabs, 0, term.col * sizeof(*term.tabs));
  for (i = tabspaces; i < term.col; i += tabspaces)
    term.tabs[i] = 1;
  term.top = 0;
  term.bot = term.row - 1;
  term.mode = MODE_WRAP | MODE_UTF8;
  memset(term.trantbl, CS_USA, sizeof(term.trantbl));
  term.charset = 0;

  for (i = 0; i < 2; i++) {
    tmoveto(0, 0);
    tcursor(CURSOR_SAVE);
    tclearregion(0, 0, term.col - 1, term.row - 1);
    tswapscreen();
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xd652(%rip), %rax      # 0x144cc
movl (%rax), %eax
leaq 0xfd09(%rip), %rcx      # 0x16b8c
movl (%rcx), %ecx
andl $0x0, 0xd944(%rip)      # 0x147d0
andw $0x0, 0xd940(%rip)      # 0x147d4
movl %eax, 0xd93e(%rip)      # 0x147d8
movl %ecx, 0xd93c(%rip)      # 0x147dc
andq $0x0, 0xd938(%rip)      # 0x147e0
movb $0x0, 0xd939(%rip)      # 0x147e8
movq 0xd95a(%rip), %rbx      # 0x14810
movslq 0xd8f7(%rip), %rdx      # 0x147b4
shlq $0x2, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x50a0
leaq 0xd5f6(%rip), %rax      # 0x144c8
movl (%rax), %ecx
movl 0xd8da(%rip), %edx      # 0x147b4
cmpl %edx, %ecx
jae 0x6eeb
movl %ecx, %esi
movl $0x1, (%rbx,%rsi,4)
addl (%rax), %ecx
jmp 0x6eda
andl $0x0, 0xd902(%rip)      # 0x147f4
movl 0xd8b8(%rip), %eax      # 0x147b0
decl %eax
movl %eax, 0xd8f8(%rip)      # 0x147f8
movl $0x41, 0xd8f2(%rip)     # 0x147fc
movq $0x3030303, 0xd8ef(%rip) # imm = 0x3030303
pushq $0x2
popq %rbx
leaq 0xfc21(%rip), %r14      # 0x16b40
subl $0x1, %ebx
jb 0x6f76
xorl %edi, %edi
xorl %esi, %esi
callq 0x702f
movl 0xd8c9(%rip), %eax      # 0x147fc
shrl $0x2, %eax
andl $0x1, %eax
imulq $0x1c, %rax, %rax
movups 0xd898(%rip), %xmm0     # 0x147dc
movups %xmm0, 0xc(%rax,%r14)
movups 0xd87f(%rip), %xmm0     # 0x147d0
movups %xmm0, (%rax,%r14)
movl 0xd858(%rip), %edx      # 0x147b4
decl %edx
movl 0xd84c(%rip), %ecx      # 0x147b0
decl %ecx
xorl %edi, %edi
xorl %esi, %esi
callq 0x709a
callq 0x71bf
jmp 0x6f1f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jaimecgomezz[P]st/st.c
// Function: tdumpsel
void tdumpsel(void) {
  char *ptr;

  if ((ptr = getsel())) {
    tprinter(ptr, strlen(ptr));
    free(ptr);
  }
}

// Assembly:
pushq %rbx
callq 0x5f3b
testq %rax, %rax
je 0x6fed
movq %rax, %rbx
movq %rax, %rdi
callq 0x5350
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7646
movq %rbx, %rdi
popq %rbx
jmp 0x5320
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jaimecgomezz[P]st/st.c
// Function: tsetscroll
void tsetscroll(int t, int b) {
  int temp;

  LIMIT(t, 0, term.row - 1);
  LIMIT(b, 0, term.row - 1);
  if (t > b) {
    temp = t;
    t = b;
    b = temp;
  }
  term.top = t;
  term.bot = b;
}

// Assembly:
xorl %eax, %eax
movl $0x0, %ecx
testl %edi, %edi
js 0x7007
movl 0xd7b0(%rip), %ecx      # 0x147b0
decl %ecx
cmpl %edi, %ecx
cmovgel %edi, %ecx
testl %esi, %esi
js 0x7018
movl 0xd79f(%rip), %eax      # 0x147b0
decl %eax
cmpl %esi, %eax
cmovgel %esi, %eax
cmpl %eax, %ecx
movl %eax, %edx
cmovgl %ecx, %edx
cmovll %ecx, %eax
movl %eax, 0xd7cc(%rip)      # 0x147f4
movl %edx, 0xd7ca(%rip)      # 0x147f8
retq
// File: /workspace/github_c_makefile_star2_O2/jaimecgomezz[P]st/st.c
// Function: tclearregion
void tclearregion(int x1, int y1, int x2, int y2) {
  int x, y, temp;
  Glyph *gp;

  if (x1 > x2)
    temp = x1, x1 = x2, x2 = temp;
  if (y1 > y2)
    temp = y1, y1 = y2, y2 = temp;

  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  LIMIT(x1, 0, term.col - 1);
  LIMIT(x2, 0, term.col - 1);
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
  LIMIT(y1, 0, term.row - 1);
  LIMIT(y2, 0, term.row - 1);

  for (y = y1; y <= y2; y++) {
    term.dirty[y] = 1;
    for (x = x1; x <= x2; x++) {
      gp = &term.line[y][x];
      // >>>>>>>>>>>>>>>>>>>> vim-browse
      // ==================== vim-browse
      if (selected(x, y))
        selclear();
      // ==================== vim-browse
      // <<<<<<<<<<<<<<<<<<<< vim-browse
      gp->fg = term.c.attr.fg;
      gp->bg = term.c.attr.bg;
      gp->mode = 0;
      gp->u = ' ';
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl %edx, %edi
movl %edx, %r8d
cmovgl %edi, %r8d
cmovll %edi, %edx
cmpl %ecx, %esi
movl %ecx, %eax
cmovll %esi, %eax
cmovgl %esi, %ecx
testl %edx, %edx
js 0x70d9
movl 0xd6ec(%rip), %esi      # 0x147b4
decl %esi
cmpl %esi, %edx
cmovll %edx, %esi
movslq %esi, %rdx
movq %rdx, 0x8(%rsp)
jmp 0x70e2
movq $0x0, 0x8(%rsp)
testl %r8d, %r8d
js 0x70fb
movl 0xd6c7(%rip), %edx      # 0x147b4
decl %edx
cmpl %edx, %r8d
cmovll %r8d, %edx
movslq %edx, %r12
jmp 0x70fe
xorl %r12d, %r12d
testl %eax, %eax
js 0x7114
movl 0xd6a8(%rip), %edx      # 0x147b0
decl %edx
cmpl %edx, %eax
cmovll %eax, %edx
movslq %edx, %rbx
jmp 0x7116
xorl %ebx, %ebx
testl %ecx, %ecx
js 0x7130
movl 0xd690(%rip), %eax      # 0x147b0
decl %eax
cmpl %eax, %ecx
cmovll %ecx, %eax
cltq
movq %rax, 0x10(%rsp)
jmp 0x7139
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %r15
shlq $0x4, %r15
orq $0x8, %r15
cmpq 0x10(%rsp), %rbx
jg 0x71b0
movq 0xd674(%rip), %rax      # 0x147c8
movl $0x1, (%rax,%rbx,4)
movq %r15, %rbp
movq 0x8(%rsp), %r14
cmpq %r12, %r14
jg 0x71ab
movq 0xd649(%rip), %rax      # 0x147b8
movq (%rax,%rbx,8), %r13
movl %r14d, %edi
movl %ebx, %esi
callq 0x5eaf
testl %eax, %eax
je 0x7186
callq 0x5c66
movq 0xd64b(%rip), %rax      # 0x147d8
movq %rax, (%r13,%rbp)
andw $0x0, -0x4(%r13,%rbp)
movl $0x20, -0x8(%r13,%rbp)
incq %r14
addq $0x10, %rbp
jmp 0x7163
incq %rbx
jmp 0x7146
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jaimecgomezz[P]st/st.c
// Function: tcursor
void tcursor(int mode) {
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  static TCursor c[2];
  int alt = IS_SET(MODE_ALTSCREEN);
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse

  if (mode == CURSOR_SAVE) {
    c[alt] = term.c;
  } else if (mode == CURSOR_LOAD) {
    term.c = c[alt];
    tmoveto(c[alt].x, c[alt].y);
  }
}

// Assembly:
movl 0xd616(%rip), %eax      # 0x147fc
shrl $0x2, %eax
andl $0x1, %eax
imulq $0x1c, %rax, %rcx
leaq 0xf949(%rip), %rax      # 0x16b40
addq %rcx, %rax
testl %edi, %edi
je 0x721e
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
movups %xmm1, 0xd5d0(%rip)     # 0x147dc
movups %xmm0, 0xd5bd(%rip)     # 0x147d0
movl 0x10(%rax), %edi
movl 0x14(%rax), %esi
jmp 0x702f
movups 0xd5b7(%rip), %xmm0     # 0x147dc
movups %xmm0, 0xc(%rax)
movups 0xd5a0(%rip), %xmm0     # 0x147d0
movups %xmm0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/jaimecgomezz[P]st/st.c
// Function: tsetchar
void tsetchar(Rune u, Glyph *attr, int x, int y) {
  static char *vt100_0[62] = {
      /* 0x41 - 0x7e */
      "↑", "↓", "→", "←", "█", "▚", "☃",      /* A - G */
      0,   0,   0,   0,   0,   0,   0,   0,   /* H - O */
      0,   0,   0,   0,   0,   0,   0,   0,   /* P - W */
      0,   0,   0,   0,   0,   0,   0,   " ", /* X - _ */
      "◆", "▒", "␉", "␌", "␍", "␊", "°", "±", /* ` - g */
      "␤", "␋", "┘", "┐", "┌", "└", "┼", "⎺", /* h - o */
      "⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */
      "│", "≤", "≥", "π", "≠", "£", "·",      /* x - ~ */
  };

  /*
   * The table is proudly stolen from rxvt.
   */
  if (term.trantbl[term.charset] == CS_GRAPHIC0 && BETWEEN(u, 0x41, 0x7e) &&
      vt100_0[u - 0x41])
    utf8decode(vt100_0[u - 0x41], &u, UTF_SIZ);

  if (term.line[y][x].mode & ATTR_WIDE) {
    if (x + 1 < term.col) {
      term.line[y][x + 1].u = ' ';
      term.line[y][x + 1].mode &= ~ATTR_WDUMMY;
    }
  } else if (term.line[y][x].mode & ATTR_WDUMMY) {
    term.line[y][x - 1].u = ' ';
    term.line[y][x - 1].mode &= ~ATTR_WIDE;
  }

  term.dirty[y] = 1;
  term.line[y][x] = *attr;
  term.line[y][x].u = u;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movl %edi, 0x4(%rsp)
addl $-0x41, %edi
cmpl $0x3d, %edi
ja 0x89b6
leaq 0xbe2c(%rip), %rax      # 0x147b0
movslq 0xbe7d(%rip), %rcx      # 0x14808
cmpb $0x0, 0x54(%rcx,%rax)
jne 0x89b6
movl %edi, %eax
leaq -0x7(%rax), %rcx
cmpq $0x17, %rcx
jb 0x89b6
leaq 0x8e9b(%rip), %rcx      # 0x11840
movq (%rcx,%rax,8), %rdi
leaq 0x4(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x772f
movq 0xbdfb(%rip), %rcx      # 0x147b8
movslq %ebp, %rax
movq (%rcx,%rax,8), %rdx
movslq %ebx, %rcx
shlq $0x4, %rcx
movzwl 0x4(%rdx,%rcx), %esi
btl $0x9, %esi
jb 0x89e4
btl $0xa, %esi
jae 0x8a05
decl %ebx
movw $0xfdff, %si            # imm = 0xFDFF
jmp 0x89f2
incl %ebx
movw $0xfbff, %si            # imm = 0xFBFF
cmpl 0xbdc4(%rip), %ebx      # 0x147b4
jge 0x8a05
movslq %ebx, %rdi
shlq $0x4, %rdi
movl $0x20, (%rdx,%rdi)
andw %si, 0x4(%rdx,%rdi)
movq 0xbdbc(%rip), %rsi      # 0x147c8
movl $0x1, (%rsi,%rax,4)
movups 0xbdb6(%rip), %xmm0     # 0x147d0
movups %xmm0, (%rdx,%rcx)
movl 0x4(%rsp), %edx
movq 0xbd8f(%rip), %rsi      # 0x147b8
movq (%rsi,%rax,8), %rax
movl %edx, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq