LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x11703
cmpl 0x120(%rbx), %eax
jl 0x1171a
movq %rbx, %rdi
movl %eax, %esi
callq 0x1156b
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 0x1173c
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_O3/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 0x117b8
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 0x2b80(%rip), %r14      # 0x14365
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x117fe
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x1180c
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rcx
testq %rcx, %rcx
je 0x11829
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x40e0
movl $0x7, %r8d
jmp 0x117e5
orb $0x8, 0x1a0(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4650
movsbq (%r14), %rcx
cmpq $0x2d, %rcx
je 0x118a9
movq (%rax), %rax
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
jne 0x118a9
movq %r14, %rdi
callq 0x41d0
leaq 0x28e7(%rip), %rsi      # 0x1415c
movq %r14, %rdi
movq %rax, %rdx
callq 0x40c0
testl %eax, %eax
je 0x118d3
leaq 0x48dd(%rip), %rsi      # 0x16168
leaq 0x48e2(%rip), %rcx      # 0x16174
movq %r15, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
jmp 0x118dc
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x44c0
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x118dc
xorl %eax, %eax
cmpq $0x0, (%rbx)
jns 0x118dc
movq $0x0, (%rbx)
jmp 0x118dc
movq $0x40000000, (%rbx)     # imm = 0x40000000
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x47cc(%rip), %rsi      # 0x16483
leaq 0x25f0(%rip), %rcx      # 0x142ae
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x4510
testq %r15, %r15
je 0x11cf4
leaq 0x3ad9(%rip), %rsi      # 0x157b6
leaq 0x4254(%rip), %rcx      # 0x15f38
movq %r14, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
leaq 0x478f(%rip), %rsi      # 0x1648a
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4510
// File: /workspace/github_c_makefile_star2_O3/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 0x1233d
movq %rdi, %r14
leaq 0x3ea7(%rip), %r15      # 0x161c3
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 0x1231c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx, %rdi
movq %rdx, %rsi
callq 0x12301
movq 0x28(%r14), %rdi
leaq 0x10(%rsp), %rsi
callq 0x43e0
testq %rax, %rax
je 0x1271d
leaq 0x3b34(%rip), %r13      # 0x161c3
movq 0x18(%rax), %rbp
cmpq $0x0, 0x10(%rbp)
je 0x126e3
movq 0x28(%r14), %rcx
leaq 0x20(%rax), %r8
cmpl $0x1, 0x3c(%rcx)
jne 0x126ab
movq (%r8), %r8
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r12, %rcx
movl 0xc(%rsp), %r9d
callq 0x11d13
movq 0x10(%rbp), %rsi
testq %rsi, %rsi
je 0x126e3
movq 0x18(%rsi), %rax
movq %rax, 0x10(%rbp)
movq %rbx, %rdi
movq %r13, %rdx
movl $0x8c7, %ecx            # imm = 0x8C7
callq 0x4280
jmp 0x126c0
testb $0x40, 0x20(%rbp)
je 0x126f7
leaq 0x3d66(%rip), %rdi      # 0x16456
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 0x4390
testq %rax, %rax
jne 0x1268f
movq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0x4210
movq 0x28(%r14), %rsi
leaq 0x3a8f(%rip), %rdx      # 0x161c3
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_O3/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 0x12c92
cmpl $0x2, %edx
jne 0x12cb3
movq 0x8(%rcx), %rsi
movq %rbx, %rdi
movl $0x200, %edx            # imm = 0x200
callq 0x4560
jmp 0x12ca7
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rbx, %rdi
movl $0x200, %ecx            # imm = 0x200
callq 0x4460
testq %rax, %rax
je 0x12cd1
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x12cd6
movq (%rcx), %rdx
leaq 0x1ba3(%rip), %rsi      # 0x14860
leaq 0x3508(%rip), %rcx      # 0x161cc
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12d10
movq (%r14), %rdx
leaq 0x1b6b(%rip), %rsi      # 0x14860
leaq 0x34e5(%rip), %rcx      # 0x161e1
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
jmp 0x12d38
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 0x12d09
incq %r12
cmpq %r12, %r15
jne 0x12d19
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12d7c
movq (%r14), %rdx
leaq 0x1aff(%rip), %rsi      # 0x14860
leaq 0x3491(%rip), %rcx      # 0x161f9
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
movl $0x1, %eax
jmp 0x12dac
movl %edx, %r15d
movl $0x2, %r12d
movq 0x8(%r14), %rsi
movq (%r14,%r12,8), %rdx
movq %rbx, %rdi
movl $0x202, %ecx            # imm = 0x202
callq 0x4460
testq %rax, %rax
je 0x12d75
incq %r12
cmpq %r12, %r15
jne 0x12d85
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13438
cmpb $0x2d, 0x1(%rbx)
jne 0x13438
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 0x4360
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x13438
cmpb $0x2d, (%rdi)
jne 0x13438
movq %rax, %r13
incq %rdi
movq %r12, %rsi
callq 0x4320
testl %eax, %eax
je 0x1346b
movq $0x0, (%rsp)
leaq 0x2fff(%rip), %rsi      # 0x16414
leaq 0x300c(%rip), %rcx      # 0x16428
leaq 0xe8c(%rip), %r9        # 0x142af
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %r8
xorl %eax, %eax
callq 0x4510
jmp 0x13459
leaq 0x2fcd(%rip), %rsi      # 0x1640c
leaq 0xe69(%rip), %rcx       # 0x142af
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x4510
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 0x13485
movq %r13, %rax
cmpl %eax, (%r15)
je 0x13459
movq 0x30(%r15), %r15
testq %r15, %r15
jne 0x13477
leaq 0x2fb3(%rip), %rsi      # 0x1643f
jmp 0x1343f
// File: /workspace/github_c_makefile_star2_O3/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 0x139eb
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 0x75de(%rip), %rbx      # 0x1aff0
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x4540
movq (%rbx), %rdi
callq 0x4430
callq 0x4070
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4380
movq %rax, %r15
testq %rbx, %rbx
je 0x13aab
movl (%r14), %esi
cmpq $0x22, %rsi
ja 0x13a95
movabsq $0x400400001, %rax      # imm = 0x400400001
btq %rsi, %rax
jb 0x13aa5
leaq 0x29f2(%rip), %rdi      # 0x1648e
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_O3/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 0x4330
movq %rax, %r15
testq %rbx, %rbx
je 0x13b2b
movl (%r14), %esi
cmpq $0x22, %rsi
ja 0x13b15
movabsq $0x400400001, %rax      # imm = 0x400400001
btq %rsi, %rax
jb 0x13b25
leaq 0x2972(%rip), %rdi      # 0x1648e
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_O3/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 0x4570
movq %rax, %r15
testq %rbx, %rbx
je 0x13bab
movl (%r14), %esi
cmpq $0x22, %rsi
ja 0x13b95
movabsq $0x400400001, %rax      # imm = 0x400400001
btq %rsi, %rax
jb 0x13ba5
leaq 0x28f2(%rip), %rdi      # 0x1648e
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_O3/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 0x13c30
movl (%r14), %esi
cmpq $0x22, %rsi
ja 0x13c0e
movabsq $0x400400001, %rax      # imm = 0x400400001
btq %rsi, %rax
jb 0x13c2a
leaq 0x2879(%rip), %rdi      # 0x1648e
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_O3/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 0x5e39
popq %rcx
retq
callq 0x5570
movl (%rax), %edi
callq 0x5430
leaq 0x8753(%rip), %rdi      # 0xe59f
movq %rax, %rsi
xorl %eax, %eax
callq 0x5e56
// File: /workspace/github_c_makefile_star2_O3/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)     # 0x1579c
je 0x6011
movl $0x0, 0xf78a(%rip)      # 0x15780
movl $0xffffffff, 0xf79c(%rip) # imm = 0xFFFFFFFF
movl 0xf78a(%rip), %edi      # 0x15790
movl 0xf78c(%rip), %esi      # 0x15798
callq 0x61ab
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0xf75e(%rip)      # 0x15780
movl 0xf7d4(%rip), %eax      # 0x157fc
shrl $0x2, %eax
andl $0x1, %eax
movl %eax, 0xf778(%rip)      # 0x157ac
movl %r14d, 0xf74d(%rip)     # 0x15788
movl %ebp, 0xf75b(%rip)      # 0x1579c
movl %ebp, 0xf75d(%rip)      # 0x157a4
movl %ebx, 0xf753(%rip)      # 0x157a0
movl %ebx, 0xf755(%rip)      # 0x157a8
callq 0x60af
cmpl $0x0, 0xf729(%rip)      # 0x15788
je 0x606b
movl $0x2, 0xf715(%rip)      # 0x15780
movl 0xf71f(%rip), %edi      # 0x15790
movl 0xf721(%rip), %esi      # 0x15798
popq %rbx
popq %r14
popq %rbp
jmp 0x61ab
// File: /workspace/github_c_makefile_star2_O3/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 %ecx, %ecx
movl $0x0, %eax
testl %edi, %edi
js 0x61c3
movl 0xf5f4(%rip), %eax      # 0x157b0
decl %eax
cmpl %edi, %eax
cmovgel %edi, %eax
testl %esi, %esi
js 0x61d4
movl 0xf5e3(%rip), %ecx      # 0x157b0
decl %ecx
cmpl %esi, %ecx
cmovgel %esi, %ecx
subl %eax, %ecx
jl 0x62e0
movq 0xf5e5(%rip), %rdx      # 0x157c8
movslq %eax, %rsi
leaq 0x4(%rcx), %rax
andq $-0x4, %rax
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdx,%rsi,4), %rcx
addq $0xc, %rcx
xorl %edx, %edx
movdqa 0x7e06(%rip), %xmm1     # 0xe010
movdqa 0x7e0e(%rip), %xmm2     # 0xe020
movdqa 0x7e16(%rip), %xmm3     # 0xe030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x626d
movl $0x1, -0xc(%rcx,%rdx,4)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x6284
movl $0x1, -0x8(%rcx,%rdx,4)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0x62c1
movl $0x1, -0x4(%rcx,%rdx,4)
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x62d3
movl $0x1, (%rcx,%rdx,4)
addq $0x4, %rdx
cmpq %rdx, %rax
jne 0x6222
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf48d(%rip), %eax      # 0x15780
testl %eax, %eax
je 0x63e1
movl %ecx, %ebx
testl %ecx, %ecx
sete %cl
cmpl $0x1, %eax
setne %al
orb %cl, %al
jne 0x634a
cmpl $-0x1, 0xf489(%rip)     # 0x1579c
je 0x63e1
movl $0x0, 0xf45d(%rip)      # 0x15780
movl $0xffffffff, 0xf46f(%rip) # imm = 0xFFFFFFFF
movl 0xf45d(%rip), %edi      # 0x15790
movl 0xf45f(%rip), %esi      # 0x15798
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x61ab
movl %edx, %ebp
movl 0xf43d(%rip), %r14d     # 0x15790
movl 0xf43e(%rip), %r15d     # 0x15798
movl 0xf423(%rip), %r12d     # 0x15784
movsd 0xf43b(%rip), %xmm0     # 0x157a4
movaps %xmm0, (%rsp)
movl %edi, 0xf431(%rip)      # 0x157a4
movl %esi, 0xf42f(%rip)      # 0x157a8
callq 0x60af
movl %ebp, 0xf400(%rip)      # 0x15784
movq 0xf418(%rip), %xmm0     # 0x157a4
pcmpeqd (%rsp), %xmm0
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
movmskpd %xmm0, %eax
cmpl $0x3, %eax
jne 0x63ad
cmpl %ebp, %r12d
jne 0x63ad
cmpl $0x1, 0xf3d5(%rip)      # 0x15780
jne 0x63d2
movl 0xf3dd(%rip), %eax      # 0x15790
cmpl %r14d, %eax
cmovll %eax, %r14d
movl 0xf3d8(%rip), %eax      # 0x15798
cmpl %r15d, %eax
cmovgl %eax, %r15d
movl %r14d, %edi
movl %r15d, %esi
callq 0x61ab
xorl %eax, %eax
testl %ebx, %ebx
sete %al
addl %eax, %eax
movl %eax, 0xf39f(%rip)      # 0x15780
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0xf389(%rip)      # 0x15780
je 0x6464
cmpl $-0x1, 0xf39c(%rip)     # 0x1579c
je 0x6464
movl 0xf3a4(%rip), %eax      # 0x157ac
btl $0x2, 0xf3ec(%rip)      # 0x157fc
sbbl $0x0, %eax
jne 0x6462
movl 0xf375(%rip), %ecx      # 0x15790
cmpl %esi, %ecx
setg %r8b
movl 0xf371(%rip), %eax      # 0x15798
cmpl %esi, %eax
setl %dl
orb %r8b, %dl
cmpl $0x2, 0xf34e(%rip)      # 0x15784
jne 0x6452
testb %dl, %dl
jne 0x6462
cmpl %edi, 0xf34a(%rip)      # 0x1578c
setle %cl
cmpl %edi, 0xf349(%rip)      # 0x15794
setge %al
andb %cl, %al
jmp 0x6464
testb %dl, %dl
jne 0x6462
cmpl %esi, %ecx
jne 0x6468
cmpl %edi, 0xf32c(%rip)      # 0x1578c
jle 0x6468
xorl %eax, %eax
movzbl %al, %eax
retq
cmpl %esi, %eax
setne %cl
cmpl %edi, 0xf321(%rip)      # 0x15794
setge %al
orb %cl, %al
jmp 0x6464
// File: /workspace/github_c_makefile_star2_O3/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 0xf1c0(%rip), %rax      # 0x157b4
movq 0xf1bd(%rip), %rcx      # 0x157b8
movslq %edi, %rdx
movq (%rcx,%rdx,8), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
testb $0x1, -0xb(%rcx,%rdx)
jne 0x6630
testl %eax, %eax
jle 0x6630
addq $-0x10, %rcx
movl %eax, %edx
shlq $0x4, %rdx
cmpl $0x20, (%rcx,%rdx)
jne 0x6630
leal -0x1(%rax), %edx
cmpl $0x1, %eax
movl %edx, %eax
jg 0x6618
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xed04(%rip), %edi      # 0x15820
movslq 0x10d0d(%rip), %rax     # 0x17830
leaq 0xed06(%rip), %rsi      # 0x15830
addq %rax, %rsi
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x51d0
movq %rax, %rbx
cmpl $-0x1, %ebx
je 0x6b90
testl %ebx, %ebx
je 0x6bad
movl 0x10ce4(%rip), %esi     # 0x17830
addl %ebx, %esi
movl %esi, 0x10cdc(%rip)     # 0x17830
leaq 0xecd5(%rip), %r14      # 0x15830
movq %r14, %rdi
xorl %edx, %edx
callq 0x6bb4
movl 0x10cc5(%rip), %ecx     # 0x17830
subl %eax, %ecx
movl %ecx, 0x10cbd(%rip)     # 0x17830
jle 0x6b85
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 0x7a92(%rip), %rdi      # 0xe635
movq %rax, %rsi
xorl %eax, %eax
callq 0x5e56
xorl %edi, %edi
callq 0x5180
// File: /workspace/github_c_makefile_star2_O3/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 0x6c98
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
xorl %ebx, %ebx
movslq %ebx, %rdi
addq %r15, %rdi
testb $0x40, 0xec1e(%rip)     # 0x157fc
jne 0x6bf1
movzbl (%rdi), %r12d
movl %r12d, 0x4(%rsp)
movl $0x1, %r13d
jmp 0x6c14
movl %r14d, %eax
subl %ebx, %eax
movslq %eax, %rdx
leaq 0x4(%rsp), %rsi
callq 0x8014
movq %rax, %r13
testl %r13d, %r13d
je 0x6c9a
movl 0x4(%rsp), %r12d
testl %ebp, %ebp
je 0x6c82
cmpl $0x20, %r12d
setae %al
cmpl $0x7f, %r12d
setne %cl
movl %r12d, %edx
andl $-0x20, %edx
cmpl $0x80, %edx
setne %dl
andb %cl, %dl
testb %al, %dl
jne 0x6c82
cmpl $0x80, %r12d
jae 0x6c65
cmpl $0xd, %r12d
ja 0x6c55
movl $0x2600, %eax           # imm = 0x2600
btl %r12d, %eax
jb 0x6c82
xorl $0x40, %r12d
movl %r12d, 0x4(%rsp)
movl $0x5e, %edi
jmp 0x6c7d
andl $0x7f, %r12d
movl %r12d, 0x4(%rsp)
movl $0x5e, %edi
callq 0x8131
movl $0x5b, %edi
callq 0x8131
movl %r12d, %edi
callq 0x8131
addl %r13d, %ebx
cmpl %r14d, %ebx
jl 0x6bd1
jmp 0x6c9a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0xe81a(%rip), %eax      # 0x157b0
cmpl $0x2, %eax
jl 0x6fdc
decl %eax
movl 0xe811(%rip), %ecx      # 0x157b4
leal -0x1(%rcx), %edx
movq 0xe80b(%rip), %rsi      # 0x157b8
shlq $0x4, %rdx
xorl %r8d, %r8d
cmpl $0x2, %ecx
jl 0x6fd4
movq (%rsi,%r8,8), %r9
xorl %r10d, %r10d
movzwl 0x4(%r9,%r10), %r11d
testl %edi, %r11d
jne 0x6fdf
addq $0x10, %r10
cmpq %r10, %rdx
jne 0x6fc0
incq %r8
cmpq %rax, %r8
jne 0x6fb4
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0xe7c5(%rip), %eax      # 0x157b0
cmpl $0x2, %eax
jl 0x705a
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl 0xe7b8(%rip), %ecx      # 0x157b4
xorl %r14d, %r14d
cmpl $0x2, %ecx
jl 0x7045
leal -0x1(%rcx), %edx
movq 0xe7aa(%rip), %rsi      # 0x157b8
movq (%rsi,%r14,8), %rsi
shlq $0x4, %rdx
xorl %edi, %edi
movzwl 0x4(%rsi,%rdi), %r8d
testl %ebx, %r8d
jne 0x702e
addq $0x10, %rdi
cmpq %rdi, %rdx
jne 0x7018
jmp 0x7045
movl %r14d, %edi
movl %r14d, %esi
callq 0x61ab
movl 0xe775(%rip), %ecx      # 0x157b4
movl 0xe76b(%rip), %eax      # 0x157b0
incq %r14
leal -0x1(%rax), %edx
movslq %edx, %rdx
cmpq %rdx, %r14
jl 0x6fff
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %rbx
pushq %rax
leaq 0xe015(%rip), %rax      # 0x154cc
movl (%rax), %eax
leaq 0x106cc(%rip), %rcx     # 0x17b8c
movl (%rcx), %ecx
movl $0x0, 0xe304(%rip)      # 0x157d0
movw $0x0, 0xe2ff(%rip)      # 0x157d4
movl %eax, 0xe2fd(%rip)      # 0x157d8
movl %ecx, 0xe2fb(%rip)      # 0x157dc
movq $0x0, 0xe2f4(%rip) # 0x157e0
movb $0x0, 0xe2f5(%rip)      # 0x157e8
movq 0xe316(%rip), %rdi      # 0x15810
movslq 0xe2b3(%rip), %rbx      # 0x157b4
movq %rbx, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x50a0
leaq 0xdfb2(%rip), %rax      # 0x154c8
movl (%rax), %ecx
cmpl %ebx, %ecx
jae 0x7538
movq 0xe2ed(%rip), %rdx      # 0x15810
movl 0xe28b(%rip), %esi      # 0x157b4
movl %ecx, %edi
movl $0x1, (%rdx,%rdi,4)
addl (%rax), %ecx
cmpl %esi, %ecx
jb 0x7529
movl $0x0, 0xe2b2(%rip)      # 0x157f4
movl 0xe268(%rip), %eax      # 0x157b0
decl %eax
movl %eax, 0xe2a8(%rip)      # 0x157f8
movl $0x41, 0xe2a2(%rip)     # 0x157fc
movq $0x3030303, 0xe29f(%rip) # imm = 0x3030303
movb $0x1, %bpl
leaq 0x105d1(%rip), %rbx     # 0x17b40
movb 0xe273(%rip), %dl       # 0x157e8
movl 0xe235(%rip), %ecx      # 0x157b0
movl %edx, %eax
andb $-0x2, %al
movb %al, 0xe263(%rip)       # 0x157e8
decl %ecx
movl %ecx, %esi
movl $0x0, %eax
testb $0x2, %dl
je 0x759f
movl 0xe25f(%rip), %esi      # 0x157f8
movl 0xe255(%rip), %eax      # 0x157f4
movl 0xe20f(%rip), %edx      # 0x157b4
decl %edx
movl %esi, %edi
sarl $0x1f, %edi
andl %esi, %edi
movl %edx, %esi
sarl $0x1f, %esi
andl %edx, %esi
testl %eax, %eax
cmovgl %eax, %edi
movl %esi, 0xe220(%rip)      # 0x157e0
movl %edi, 0xe21e(%rip)      # 0x157e4
movl 0xe230(%rip), %eax      # 0x157fc
shrl $0x2, %eax
andl $0x1, %eax
leaq (%rax,%rax,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rax, %rsi
movups 0xe1ec(%rip), %xmm0     # 0x157d0
movups %xmm0, (%rbx,%rsi)
movups 0xe1ed(%rip), %xmm0     # 0x157dc
movups %xmm0, 0xc(%rbx,%rsi)
xorl %edi, %edi
xorl %esi, %esi
callq 0x76f9
callq 0x7867
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x756f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x647a
testq %rax, %rax
je 0x768c
movq %rax, %rbx
movq %rax, %rdi
callq 0x5350
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f3a
movq %rbx, %rdi
popq %rbx
jmp 0x5320
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
testl %edx, %edx
js 0x7743
movl 0xe07c(%rip), %esi      # 0x157b4
decl %esi
cmpl %esi, %edx
cmovll %edx, %esi
movl %esi, 0x4(%rsp)
testl %r8d, %r8d
js 0x775c
movl 0xe066(%rip), %edx      # 0x157b4
decl %edx
cmpl %edx, %r8d
cmovll %r8d, %edx
movq %rdx, 0x8(%rsp)
movl $0x0, (%rsp)
movl $0x0, %edx
testl %eax, %eax
js 0x7779
movl 0xe03e(%rip), %edx      # 0x157b0
decl %edx
cmpl %edx, %eax
cmovll %eax, %edx
testl %ecx, %ecx
js 0x778d
movl 0xe02d(%rip), %eax      # 0x157b0
decl %eax
cmpl %eax, %ecx
cmovll %ecx, %eax
movl %eax, (%rsp)
cmpl (%rsp), %edx
jg 0x7858
movslq 0x4(%rsp), %rcx
movq 0x8(%rsp), %rax
leal 0x1(%rax), %r13d
movslq %edx, %rbx
incl (%rsp)
shlq $0x4, %rcx
orq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq 0xe00a(%rip), %rax      # 0x157c8
movl $0x1, (%rax,%rbx,4)
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
jg 0x784c
movq 0xdfe2(%rip), %r12      # 0x157b8
movq 0x10(%rsp), %r14
movl 0x4(%rsp), %ebp
movq (%r12,%rbx,8), %r15
movl %ebp, %edi
movl %ebx, %esi
callq 0x63ee
testl %eax, %eax
je 0x7825
cmpl $-0x1, 0xdfa5(%rip)     # 0x1579c
je 0x7825
movl $0x0, 0xdf7d(%rip)      # 0x15780
movl $0xffffffff, 0xdf8f(%rip) # imm = 0xFFFFFFFF
movl 0xdf7d(%rip), %edi      # 0x15790
movl 0xdf7f(%rip), %esi      # 0x15798
callq 0x61ab
movq 0xdf93(%rip), %r12      # 0x157b8
movq 0xdfac(%rip), %rax      # 0x157d8
movq %rax, (%r15,%r14)
movw $0x0, -0x4(%r15,%r14)
movl $0x20, -0x8(%r15,%r14)
incl %ebp
addq $0x10, %r14
cmpl %ebp, %r13d
jne 0x77df
incq %rbx
cmpl %ebx, (%rsp)
jne 0x77b7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xde58(%rip), %ecx      # 0x157fc
shrl $0x2, %ecx
andl $0x1, %ecx
leaq (%rcx,%rcx,8), %rax
leaq (%rax,%rax,2), %rdx
leaq 0x10187(%rip), %rax     # 0x17b40
addq %rcx, %rax
addq %rdx, %rax
testl %edi, %edi
je 0x79e3
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
movups %xmm1, 0xde0b(%rip)     # 0x157dc
movups %xmm0, 0xddf8(%rip)     # 0x157d0
movl 0x10(%rax), %edi
movl 0x14(%rax), %esi
jmp 0x768e
movups 0xddf2(%rip), %xmm0     # 0x157dc
movups %xmm0, 0xc(%rax)
movups 0xdddb(%rip), %xmm0     # 0x157d0
movups %xmm0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x91e5
leaq 0xc5ff(%rip), %rax      # 0x157b0
movslq 0xc650(%rip), %rcx      # 0x15808
cmpb $0x0, 0x54(%rcx,%rax)
jne 0x91e5
movl %edi, %eax
leaq -0x7(%rax), %rcx
cmpq $0x17, %rcx
jb 0x91e5
leaq 0x966e(%rip), %rcx      # 0x12840
movq (%rcx,%rax,8), %rdi
leaq 0x4(%rsp), %rsi
movl $0x4, %edx
callq 0x8014
movq 0xc5cc(%rip), %rcx      # 0x157b8
movslq %ebp, %rax
movq (%rcx,%rax,8), %rdx
movslq %ebx, %rcx
shlq $0x4, %rcx
movzwl 0x4(%rdx,%rcx), %esi
btl $0x9, %esi
jb 0x9213
btl $0xa, %esi
jae 0x9234
decl %ebx
movw $0xfdff, %si            # imm = 0xFDFF
jmp 0x9221
incl %ebx
movw $0xfbff, %si            # imm = 0xFBFF
cmpl 0xc595(%rip), %ebx      # 0x157b4
jge 0x9234
movslq %ebx, %rdi
shlq $0x4, %rdi
movl $0x20, (%rdx,%rdi)
andw %si, 0x4(%rdx,%rdi)
movq 0xc58d(%rip), %rsi      # 0x157c8
movl $0x1, (%rsi,%rax,4)
movups 0xc587(%rip), %xmm0     # 0x157d0
movups %xmm0, (%rdx,%rcx)
movl 0x4(%rsp), %edx
movq 0xc560(%rip), %rsi      # 0x157b8
movq (%rsi,%rax,8), %rax
movl %edx, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jaimecgomezz[P]st/st.c
// Function: tputtab
void tputtab(int n) {
  uint x = term.c.x;

  if (n > 0) {
    while (x < term.col && n--)
      for (++x; x < term.col && !term.tabs[x]; ++x)
        /* nothing */;
  } else if (n < 0) {
    while (x > 0 && n++)
      for (--x; x > 0 && !term.tabs[x]; --x)
        /* nothing */;
  }
  term.c.x = LIMIT(x, 0, term.col - 1);
}

// Assembly:
movl 0xc574(%rip), %eax      # 0x157e0
testl %edi, %edi
jle 0x92a8
movl 0xc53e(%rip), %edx      # 0x157b4
cmpl %edx, %eax
jae 0x92e5
movq 0xc58f(%rip), %rsi      # 0x15810
subl $0x1, %edi
jb 0x92e5
movl %eax, %r8d
incq %r8
movl %eax, %ecx
cmpq %rdx, %r8
jae 0x92de
incl %ecx
cmpl $0x0, (%rsi,%r8,4)
leaq 0x1(%r8), %r8
je 0x928e
movl %ecx, %eax
cmpl %ecx, %edx
ja 0x9281
jmp 0x92e7
setne %cl
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x92e5
movq 0xc552(%rip), %rdx      # 0x15810
incl %edi
decl %eax
movl %eax, %ecx
subl $0x1, %ecx
jb 0x92fb
movl %eax, %eax
cmpl $0x0, (%rdx,%rax,4)
movl %ecx, %eax
je 0x92c4
leal 0x1(%rcx), %eax
testl %edi, %edi
jne 0x92be
incl %ecx
jmp 0x92e7
incl %eax
cmpl %eax, %edx
cmoval %edx, %eax
movl %eax, %ecx
movl 0xc4c7(%rip), %eax      # 0x157b4
decl %eax
cmpl %eax, %ecx
cmovbl %ecx, %eax
movl %eax, 0xc4e6(%rip)      # 0x157e0
retq
xorl %ecx, %ecx
jmp 0x92e7