LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_CdCmd
int
Hax_CdCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    UnixClientData *clientDataPtr;
    Hax_Memoryp *memoryp;
    char *dirName;

    memoryp = Hax_GetMemoryp(interp);
    clientDataPtr = (UnixClientData *) clientData;

    if (argc > 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" dirName\"", (char *) NULL);
	return HAX_ERROR;
    }

    if (argc == 2) {
	dirName = argv[1];
    } else {
	dirName = (char *) "~";
    }
    dirName = Hax_TildeSubst(interp, clientData, dirName);
    if (dirName == NULL) {
	return HAX_ERROR;
    }
    if (clientDataPtr->currentDir != NULL) {
	ckfree(memoryp, clientDataPtr->currentDir);
	clientDataPtr->currentDir = NULL;
    }
    if (chdir(dirName) != 0) {
	Hax_AppendResult(interp, "couldn't change working directory to \"",
		dirName, "\": ", Hax_UnixError(interp), (char *) NULL);
	return HAX_ERROR;
    }
    return HAX_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3540
cmpl $0x3, %ebp
jl 0x4818
movq (%r15), %rdx
leaq 0x4949(%rip), %rsi      # 0x9143
leaq 0x4a67(%rip), %rcx      # 0x9268
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3510
movl $0x1, %ebp
jmp 0x48a3
movq %rax, %r12
cmpl $0x2, %ebp
jne 0x4826
movq 0x8(%r15), %rdx
jmp 0x482d
leaq 0x4a45(%rip), %rdx      # 0x9272
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3570
movl $0x1, %ebp
testq %rax, %rax
je 0x48a3
movq %rax, %r15
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x486a
leaq 0x4a1f(%rip), %rdx      # 0x9274
movq %r12, %rdi
movl $0x79, %ecx
callq 0x31f0
movq $0x0, 0x18(%r14)
movq %r15, %rdi
callq 0x31c0
testl %eax, %eax
je 0x48a1
movq %rbx, %rdi
callq 0x31b0
leaq 0x49fb(%rip), %rsi      # 0x9280
leaq 0x495f(%rip), %rcx      # 0x91eb
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x3510
jmp 0x48a3
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_EofCmd
int
Hax_EofCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    UnixClientData *clientDataPtr;
    OpenFile *filePtr;

    if (argc != 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" fileId\"", (char *) NULL);
	return HAX_ERROR;
    }

    clientDataPtr = (UnixClientData *) clientData;
    if (HaxGetOpenFile(interp, clientDataPtr, argv[1], &filePtr) != HAX_OK) {
	return HAX_ERROR;
    }
    if (feof(filePtr->f)) {
	interp->result = (char *) "1";
    } else {
	interp->result = (char *) "0";
    }
    return HAX_OK;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x2, %edx
jne 0x4d24
movq %rdi, %rsi
movq 0x8(%rcx), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x3060
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x4d47
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x3370
testl %eax, %eax
leaq 0x45a5(%rip), %rax      # 0x92b7
leaq 0x5226(%rip), %rcx      # 0x9f3f
cmoveq %rax, %rcx
movq %rcx, (%rbx)
xorl %eax, %eax
jmp 0x4d47
movq (%rcx), %rdx
leaq 0x4415(%rip), %rsi      # 0x9143
leaq 0x4986(%rip), %rcx      # 0x96bb
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3510
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_ExitCmd
int
Hax_ExitCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    int value;

    if ((argc != 1) && (argc != 2)) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" ?returnCode?\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (argc == 1) {
	exit(0);
    }
    if (Hax_GetInt(interp, argv[1], &value) != HAX_OK) {
	return HAX_ERROR;
    }
    exit(value);
    return HAX_OK;			/* Better not ever reach this! */
}

// Assembly:
pushq %rax
leal -0x3(%rdx), %eax
cmpl $-0x3, %eax
ja 0x4f19
movq (%rcx), %rdx
leaq 0x4243(%rip), %rax      # 0x9143
leaq 0x43d3(%rip), %rcx      # 0x92da
movq %rsi, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3510
jmp 0x4f36
cmpl $0x1, %edx
je 0x4f3d
movq 0x8(%rcx), %rax
leaq 0x4(%rsp), %rdx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x3180
testl %eax, %eax
je 0x4f44
movl $0x1, %eax
popq %rcx
retq
xorl %edi, %edi
callq 0x35b0
movl 0x4(%rsp), %edi
callq 0x35b0
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_FlushCmd
int
Hax_FlushCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    UnixClientData *clientDataPtr;
    OpenFile *filePtr;
    FILE *f;

    if (argc != 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" fileId\"", (char *) NULL);
	return HAX_ERROR;
    }

    clientDataPtr = (UnixClientData *) clientData;
    if (HaxGetOpenFile(interp, clientDataPtr, argv[1], &filePtr) != HAX_OK) {
	return HAX_ERROR;
    }
    if (!filePtr->writable) {
	Hax_AppendResult(interp, "\"", argv[1],
		"\" wasn't opened for writing", (char *) NULL);
	return HAX_ERROR;
    }
    f = filePtr->f2;
    if (f == NULL) {
	f = filePtr->f;
    }
    if (fflush(f) == EOF) {
	Hax_AppendResult(interp, "error flushing \"", argv[1],
		"\": ", Hax_UnixError(interp), (char *) NULL);
	clearerr(f);
	return HAX_ERROR;
    }
    return HAX_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x2, %edx
jne 0x5c5c
movq %rdi, %rsi
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x3060
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x5c7f
movq 0x8(%rsp), %rax
cmpl $0x0, 0x14(%rax)
je 0x5c89
movq 0x8(%rax), %r15
testq %r15, %r15
jne 0x5c14
movq (%rax), %r15
movq %r15, %rdi
callq 0x3420
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x5c7f
movq 0x8(%r14), %r14
movq %rbx, %rdi
callq 0x31b0
leaq 0x3876(%rip), %rsi      # 0x94ae
leaq 0x35ac(%rip), %rcx      # 0x91eb
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x3510
movq %r15, %rdi
callq 0x33a0
jmp 0x5c7a
movq (%r14), %rdx
leaq 0x34dd(%rip), %rsi      # 0x9143
leaq 0x3a4e(%rip), %rcx      # 0x96bb
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3510
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rdx
leaq 0x348c(%rip), %rsi      # 0x9120
leaq 0x37f7(%rip), %rcx      # 0x9492
jmp 0x5c6d
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_PwdCmd
int
Hax_PwdCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    Hax_Memoryp *memoryp;
    UnixClientData *clientDataPtr;
    char buffer[MAXPATHLEN+1];

    memoryp = Hax_GetMemoryp(interp);
    clientDataPtr = (UnixClientData *) clientData;

    if (argc != 1) {
	Hax_AppendResult(interp, "wrong # args: should be \"",
		argv[0], "\"", (char *) NULL);
	return HAX_ERROR;
    }
    if (clientDataPtr->currentDir == NULL) {
	if (getcwd(buffer, MAXPATHLEN) == NULL) {
	    if (errno == ERANGE) {
		interp->result = (char *) "working directory name is too long";
	    } else {
		Hax_AppendResult(interp,
			"error getting working directory name: ",
			Hax_UnixError(interp), (char *) NULL);
	    }
	    return HAX_ERROR;
	}
	clientDataPtr->currentDir = (char *) ckalloc(memoryp, (unsigned)
		(strlen(buffer) + 1));
	strcpy(clientDataPtr->currentDir, buffer);
    }
    interp->result = clientDataPtr->currentDir;
    return HAX_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1010, %rsp           # imm = 0x1010
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3540
cmpl $0x1, %ebp
jne 0x6306
cmpq $0x0, 0x18(%r14)
jne 0x62fb
movq %rax, %r15
movq %rsp, %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x3280
testq %rax, %rax
je 0x633a
movq %rsp, %r12
movq %r12, %rdi
callq 0x3190
leal 0x1(%rax), %esi
leaq 0x2f95(%rip), %rdx      # 0x9274
movq %r15, %rdi
movl $0x4cb, %ecx            # imm = 0x4CB
callq 0x34c0
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %r12, %rsi
callq 0x30e0
movq 0x18(%r14), %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x632a
movq (%r12), %rdx
leaq 0x2e32(%rip), %rsi      # 0x9143
leaq 0x2e08(%rip), %rcx      # 0x9120
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3510
movl $0x1, %eax
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3080
cmpl $0x22, (%rax)
jne 0x6350
leaq 0x3297(%rip), %rax      # 0x95e2
movq %rax, (%rbx)
jmp 0x6325
movq %rbx, %rdi
callq 0x31b0
leaq 0x32a6(%rip), %rsi      # 0x9605
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3510
jmp 0x6325
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_TellCmd
int
Hax_TellCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    UnixClientData *clientDataPtr;
    OpenFile *filePtr;

    if (argc != 2) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" fileId\"", (char *) NULL);
	return HAX_ERROR;
    }

    clientDataPtr = (UnixClientData *) clientData;
    if (HaxGetOpenFile(interp, clientDataPtr, argv[1], &filePtr) != HAX_OK) {
	return HAX_ERROR;
    }
    sprintf(interp->result, "%lld", (long long int) ftello(filePtr->f));
    return HAX_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x2, %edx
jne 0x69d2
movq %rdi, %rsi
movq 0x8(%rcx), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x3060
movl $0x1, %ebp
testl %eax, %eax
jne 0x69f5
movq (%rbx), %rbx
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x30f0
leaq 0x2d74(%rip), %rsi      # 0x9735
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x35a0
jmp 0x69f5
movq (%rcx), %rdx
leaq 0x2767(%rip), %rsi      # 0x9143
leaq 0x2cd8(%rip), %rcx      # 0x96bb
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3510
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_TimeCmd
int
Hax_TimeCmd(
    ClientData clientData,		/* Unix ClientData */
    Hax_Interp *interp,			/* Current interpreter. */
    int argc,				/* Number of arguments. */
    char **argv				/* Argument strings. */)
{
    long long int count, i, result;
    double timePer;
    struct timeval start, stop;
    struct timezone tz;
    int micros;

    if (argc == 2) {
	count = 1;
    } else if (argc == 3) {
	if (Hax_GetLongLong(interp, argv[2], &count) != HAX_OK) {
	    return HAX_ERROR;
	}
    } else {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" command ?count?\"", (char *) NULL);
	return HAX_ERROR;
    }
    gettimeofday(&start, &tz);
    for (i = count ; i > 0; i--) {
	result = Hax_Eval(interp, NULL, argv[1], 0, (char **) NULL);
	if (result != HAX_OK) {
	    if (result == HAX_ERROR) {
		char msg[60];
		sprintf(msg, "\n    (\"time\" body line %d)",
			interp->errorLine);
		Hax_AddErrorInfo(interp, msg);
	    }
	    return result;
	}
    }
    gettimeofday(&stop, &tz);
    micros = (stop.tv_sec - start.tv_sec)*1000000
	    + (stop.tv_usec - start.tv_usec);
    timePer = micros;

    Hax_ResetResult(interp);
    sprintf(interp->result, "%.0f microseconds per iteration", timePer/count);
    return HAX_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r14
movq %rsi, %rbx
cmpl $0x3, %edx
je 0x6a27
cmpl $0x2, %edx
jne 0x6ae6
movq $0x1, 0x8(%rsp)
jmp 0x6a45
movq 0x10(%r14), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x35c0
movl $0x1, %ebp
testl %eax, %eax
jne 0x6b36
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3230
movq 0x8(%rsp), %r15
testq %r15, %r15
jle 0x6a85
incq %r15
movq 0x8(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3590
testl %eax, %eax
jne 0x6b0b
decq %r15
cmpq $0x1, %r15
jg 0x6a61
leaq 0x30(%rsp), %r14
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x3230
movl (%r14), %eax
movl 0x8(%r14), %ecx
subl 0x20(%rsp), %eax
subl 0x28(%rsp), %ecx
imull $0xf4240, %eax, %eax    # imm = 0xF4240
addl %eax, %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x3270
movq (%rbx), %rdi
cvtsi2sdq 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
divsd %xmm1, %xmm0
leaq 0x2c8c(%rip), %rsi      # 0x9767
movb $0x1, %al
callq 0x35a0
xorl %ebp, %ebp
jmp 0x6b36
movq (%r14), %rdx
leaq 0x2653(%rip), %rsi      # 0x9143
leaq 0x2c43(%rip), %rcx      # 0x973a
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3510
movl $0x1, %ebp
jmp 0x6b36
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x6b36
movl 0x10(%rbx), %edx
leaq 0x2c30(%rip), %rsi      # 0x974c
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x35a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3400
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxUnixAZ.c
// Function: Hax_InitUnixCore
ClientData
Hax_InitUnixCore(
    Hax_Interp *interp)
{
    Hax_Memoryp *memoryp;
    CmdInfo *cmdInfoPtr;
    UnixClientData *clientDataPtr;
    char *libraryPath;

    memoryp = Hax_GetMemoryp(interp);

    clientDataPtr = (UnixClientData *) ckalloc(memoryp, sizeof(UnixClientData));
    clientDataPtr->numFiles = 0;
    clientDataPtr->filePtrArray = NULL;
    clientDataPtr->refCount = 0;
    clientDataPtr->currentDir = NULL;
    memset(&clientDataPtr->staticBuf, 0, sizeof(clientDataPtr->staticBuf));
    clientDataPtr->curSize = STATIC_BUF_SIZE;
    clientDataPtr->curBuf = clientDataPtr->staticBuf;
    clientDataPtr->environSize = 0;
    clientDataPtr->haxEnviron = NULL;
    clientDataPtr->waitTable = NULL;
    clientDataPtr->waitTableSize = 0;
    clientDataPtr->waitTableUsed = 0;

    for (cmdInfoPtr = builtInCmds; cmdInfoPtr->name != NULL;
	 cmdInfoPtr++) {
	Hax_CreateCommand (interp, (char *) cmdInfoPtr->name,
	                   cmdInfoPtr->proc, (ClientData) clientDataPtr,
	                   Hax_UnixCoreDelete);

	clientDataPtr->refCount++;
    }

    libraryPath = getenv("HAX_LIBRARY");
    if (libraryPath != NULL) {
	Hax_SetLibraryPath(interp, libraryPath);
    }

    HaxSetupEnv(interp, clientDataPtr);

    return (ClientData) clientDataPtr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x3540
leaq 0x257c(%rip), %rdx      # 0x9274
movl $0x98, %esi
movq %rax, %rdi
movl $0x756, %ecx            # imm = 0x756
callq 0x34c0
movq %rax, %r14
xorl %eax, %eax
movl %eax, (%r14)
movq %rax, 0x8(%r14)
movl %eax, 0x10(%r14)
leaq 0x20(%r14), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x42(%r14)
movl $0x32, 0x54(%r14)
movq %rcx, 0x58(%r14)
movl %eax, 0x60(%r14)
movq %rax, 0x68(%r14)
movups %xmm0, 0x88(%r14)
leaq 0x2b3d(%rip), %rsi      # 0x9895
leaq 0x5f71(%rip), %r12      # 0xccd0
movq 0x6272(%rip), %r15      # 0xcfd8
movq -0x8(%r12), %rdx
movq (%r12), %r13
movq %rbx, %rdi
movq %r14, %rcx
movq %r15, %r8
callq 0x3030
incl 0x10(%r14)
addq $0x10, %r12
movq %r13, %rsi
testq %r13, %r13
jne 0x6d66
leaq 0x29f3(%rip), %rdi      # 0x9787
callq 0x3050
testq %rax, %rax
je 0x6da9
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3040
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3410
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxUnixUtil.c
// Function: Hax_UnixError
char *
Hax_UnixError(
    Hax_Interp *interp		/* Interpreter whose $errorCode variable
				 * is to be changed. */)
{
    char *id, *msg;

    id = Hax_ErrnoId();
    msg = strerror(errno);
    Hax_SetErrorCode(interp, "UNIX", id, msg, (char *) NULL);
    return msg;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x34b0
movq %rax, %r14
callq 0x3080
movl (%rax), %edi
callq 0x35d0
movq %rax, %r15
leaq 0x34ff(%rip), %rsi      # 0xa575
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3490
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/haxUnixUtil.c
// Function: Hax_DetachPids
void
Hax_DetachPids(
    ClientData clientData,
    int numPids,		/* Number of pids to detach:  gives size
				 * of array pointed to by pidPtr. */
    int *pidPtr			/* Array of pids to detach:  must have
				 * been created by Hax_Fork. */)
{
    UnixClientData *unixClientData = (UnixClientData *) clientData;
    WaitInfo *waitPtr;
    int i, count, pid;

    for (i = 0; i < numPids; i++) {
	pid = pidPtr[i];
	for (waitPtr = unixClientData->waitTable,
		count = unixClientData->waitTableUsed;
		count > 0; waitPtr++, count--) {
	    if (pid != waitPtr->pid) {
		continue;
	    }

	    /*
	     * If the process has already exited then destroy its
	     * table entry now.
	     */

	    if ((waitPtr->flags & WI_READY) && (WIFEXITED(waitPtr->status)
		    || WIFSIGNALED(waitPtr->status))) {
		*waitPtr = unixClientData->waitTable
			[unixClientData->waitTableUsed-1];
		unixClientData->waitTableUsed--;
	    } else {
		waitPtr->flags |= WI_DETACHED;
	    }
	    goto nextPid;
	}
	Hax_Panic((char *) "Hax_Detach couldn't find process");

	nextPid:
	continue;
    }
}

// Assembly:
testl %esi, %esi
jle 0x739d
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r12d
leaq 0x3009(%rip), %r15      # 0xa30e
xorl %r13d, %r13d
movslq 0x94(%r14), %rax
testq %rax, %rax
jle 0x7336
movl (%rbx,%r13,4), %esi
movq 0x88(%r14), %rdx
leaq 0x8(%rdx), %rcx
leal 0x1(%rax), %edi
cmpl -0x8(%rcx), %esi
je 0x7342
addq $0xc, %rcx
decl %edi
cmpl $0x1, %edi
jg 0x7326
movq %r15, %rdi
xorl %eax, %eax
callq 0x3130
jmp 0x7388
movl (%rcx), %esi
testb $0x1, %sil
je 0x7383
movl -0x4(%rcx), %edi
andl $0x7f, %edi
je 0x7363
shll $0x18, %edi
addl $0x1000000, %edi        # imm = 0x1000000
cmpl $0x2000000, %edi        # imm = 0x2000000
jl 0x7383
addq $-0x8, %rcx
leaq (%rax,%rax,2), %rax
movl -0x4(%rdx,%rax,4), %esi
movl %esi, 0x8(%rcx)
movq -0xc(%rdx,%rax,4), %rax
movq %rax, (%rcx)
decl 0x94(%r14)
jmp 0x7388
orl $0x2, %esi
movl %esi, (%rcx)
incq %r13
cmpq %r12, %r13
jne 0x7308
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_06/buftype.c
// Function: print_buftype
void print_buftype(char *name, int mode, size_t size)
{
	if (mode)
		fprintf(stderr, "%s is line buffered\n", name);
	else if (size > 1)
		fprintf(stderr, "%s is fully buffered, "
				"size is %ld bytes\n",
				name, size);
	else
		fprintf(stderr, "%s is unbuffered\n", name);
}

// Assembly:
movq %rdx, %rcx
movq %rdi, %rdx
movq 0x2e7f(%rip), %rax      # 0x3ff8
testl %esi, %esi
jne 0x1194
movq (%rax), %rdi
cmpq $0x2, %rcx
jb 0x11a0
leaq 0xe8c(%rip), %rsi       # 0x2019
xorl %eax, %eax
jmp 0x1040
movq (%rax), %rdi
leaq 0xe66(%rip), %rsi       # 0x2004
jmp 0x11a7
leaq 0xe9b(%rip), %rsi       # 0x2042
xorl %eax, %eax
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_06/buftype.c
// Function: main
int main(void)
{
	/* The following two operations are needed to force
	 * the underlying mechanisms to correctly setup
	 * its internal data.
	 */
	fseek(stdout, 0, SEEK_SET);
	fseek(stdin, 0, SEEK_SET);

	/* Got stdin data information */
	print_buftype("stdin", __flbf(stdin),
				__fbufsize(stdin));

	/* Got stdin data information */
	print_buftype("stdout", __flbf(stdout),
				__fbufsize(stdout));

	/* Got stderr data information */
	print_buftype("stderr", __flbf(stderr),
				__fbufsize(stderr));
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x2e16(%rip), %r14      # 0x3fd0
movq (%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1050
movq 0x2e0b(%rip), %r15      # 0x3fd8
movq (%r15), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1050
movq (%r15), %rdi
callq 0x1030
movl %eax, %ebx
movq (%r15), %rdi
callq 0x1060
leaq 0xe62(%rip), %rdi       # 0x2054
movl %ebx, %esi
movq %rax, %rdx
callq 0x116c
movq (%r14), %rdi
callq 0x1030
movl %eax, %ebx
movq (%r14), %rdi
callq 0x1060
leaq 0xe45(%rip), %rdi       # 0x205a
movl %ebx, %esi
movq %rax, %rdx
callq 0x116c
movq 0x2dd2(%rip), %r14      # 0x3ff8
movq (%r14), %rdi
callq 0x1030
movl %eax, %ebx
movq (%r14), %rdi
callq 0x1060
leaq 0xe22(%rip), %rdi       # 0x2061
movl %ebx, %esi
movq %rax, %rdx
callq 0x116c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/pread3.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	int fd = open(tmpfile, O_RDONLY);
	unsigned long offset = getpagesize() * nr;

	assert(fd >= 0);

	while (1) {
		assert(pread(fd, buf, BUFLEN, offset) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x24c8(%rip), %rdi      # 0x5190
xorl %esi, %esi
xorl %eax, %eax
callq 0x2210
movl %eax, %ebp
callq 0x2290
testl %ebp, %ebp
js 0x2d3c
movslq %eax, %r14
imulq %r15, %r14
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rcx
callq 0x2270
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2d1d
movq %rsp, %r15
incq (%rbx)
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rcx
callq 0x2270
cmpq $0x1000, %rax           # imm = 0x1000
je 0x2d00
leaq 0x5de(%rip), %rdi       # 0x3302
leaq 0x56a(%rip), %rsi       # 0x3295
leaq 0x59d(%rip), %rcx       # 0x32cf
movl $0x28, %edx
callq 0x2120
leaq 0x54a(%rip), %rdi       # 0x328d
leaq 0x54b(%rip), %rsi       # 0x3295
leaq 0x57e(%rip), %rcx       # 0x32cf
movl $0x25, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/chatziko-k08[P]lecture-code/tests/../modules/UsingBinarySearchTree/ADTSet.c
// Function: node_is_bst
static bool node_is_bst(SetNode node, CompareFunc compare) {
	if (node == NULL)
		return true;

	// Ελέγχουμε την ιδιότητα:
	// κάθε κόμβος είναι > αριστερό παιδί, > δεξιότερο κόμβο του αριστερού υποδέντρου, < δεξί παιδί, < αριστερότερο κόμβο του δεξιού υποδέντρου.
	// Είναι ισοδύναμη με την BST ιδιότητα (κάθε κόμβος είναι > αριστερό υποδέντρο και < δεξί υποδέντρο) αλλά ευκολότερο να ελεγθεί.
	bool res = true;
	if(node->left != NULL)
		res = res && compare(node->left->value, node->value) < 0 && compare(node_find_max(node->left)->value, node->value) < 0;
	if(node->right != NULL)
		res = res && compare(node->right->value, node->value) > 0 && compare(node_find_min(node->right)->value, node->value) > 0;

	return res &&
		node_is_bst(node->left, compare) &&
		node_is_bst(node->right, compare);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0x537a
movq (%r14), %rax
testq %rax, %rax
je 0x530a
movq 0x10(%rax), %rdi
movq 0x10(%r14), %rsi
callq *%rbx
testl %eax, %eax
js 0x530e
xorl %eax, %eax
jmp 0x5323
movb $0x1, %al
jmp 0x5323
movq (%r14), %rdi
callq 0x51ec
movq 0x10(%rax), %rdi
movq 0x10(%r14), %rsi
callq *%rbx
shrl $0x1f, %eax
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x535a
testb %al, %al
je 0x5358
movq 0x10(%rcx), %rdi
movq 0x10(%r14), %rsi
callq *%rbx
testl %eax, %eax
jle 0x5358
movq 0x8(%r14), %rdi
callq 0x51d6
movq 0x10(%rax), %rdi
movq 0x10(%r14), %rsi
callq *%rbx
testl %eax, %eax
setg %al
jmp 0x535a
xorl %eax, %eax
testb %al, %al
je 0x5376
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x52dd
testb %al, %al
je 0x5376
movq 0x8(%r14), %r14
jmp 0x52e7
xorl %eax, %eax
jmp 0x537c
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/chatziko-k08[P]lecture-code/tests/../modules/UsingBinarySearchTree/ADTSet.c
// Function: node_remove_min
static SetNode node_remove_min(SetNode node, SetNode* min_node) {
	if (node->left == NULL) {
		// Δεν έχουμε αριστερό υποδέντρο, οπότε ο μικρότερος είναι ο ίδιος ο node
		*min_node = node;
		return node->right;		// νέα ρίζα είναι το δεξιό παιδί

	} else {
		// Εχουμε αριστερό υποδέντρο, οπότε η μικρότερη τιμή είναι εκεί. Συνεχίζουμε αναδρομικά
		// και ενημερώνουμε το node->left με τη νέα ρίζα του υποδέντρου.
		node->left = node_remove_min(node->left, min_node);
		return node;			// η ρίζα δεν μεταβάλλεται
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x539a
callq 0x5384
movq %rax, (%rbx)
jmp 0x53a1
movq %rbx, (%rsi)
movq 0x8(%rbx), %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/martin-decky[P]ichiglyph/interpreter/ichiglyph/ichiglyph.c
// Function: opcode_decode
static instruction_t opcode_decode(ichiglyph_opcode_t opcode)
{
	switch (opcode[0]) {
	case 'l':
		switch (opcode[1]) {
		case 'l':
			return INST_DP_INC;
		case 'I':
			return INST_DP_DEC;
		case '1':
			return INST_JMP_FORWARD;
		default:
			return INST_NOP;
		}
	case 'I':
		switch (opcode[1]) {
		case 'l':
			return INST_VAL_INC;
		case 'I':
			return INST_VAL_DEC;
		case '1':
			return INST_JMP_BACK;
		default:
			return INST_NOP;
		}
	case '1':
		switch (opcode[1]) {
		case 'l':
			return INST_VAL_OUTPUT;
		case 'I':
			return INST_VAL_ACCEPT;
		default:
			return INST_NOP;
		}
	default:
		return INST_NOP;
	}
}

// Assembly:
movzbl (%rdi), %ecx
cmpl $0x31, %ecx
je 0x16e5
movl $0x8, %eax
cmpl $0x49, %ecx
je 0x16cc
cmpl $0x6c, %ecx
jne 0x16ff
movzbl 0x1(%rdi), %ecx
cmpl $0x31, %ecx
je 0x170f
cmpl $0x6c, %ecx
je 0x170c
cmpl $0x49, %ecx
jne 0x16ff
movl $0x1, %eax
retq
movzbl 0x1(%rdi), %ecx
cmpl $0x31, %ecx
je 0x1706
cmpl $0x6c, %ecx
je 0x1700
cmpl $0x49, %ecx
jne 0x16ff
movl $0x3, %eax
retq
movb 0x1(%rdi), %al
xorl %ecx, %ecx
cmpb $0x49, %al
setne %cl
leal (%rcx,%rcx,2), %ecx
addl $0x5, %ecx
cmpb $0x6c, %al
movl $0x4, %eax
cmovnel %ecx, %eax
retq
movl $0x2, %eax
retq
movl $0x7, %eax
retq
xorl %eax, %eax
retq
movl $0x6, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_02/syscalls.c
// Function: main
int main(void)
{
  FILE *file_p;

  if ((file_p = file_open("syscalls.c", "r")) == NULL)
  {
    write(1, "Error: could not open the file.\n", 33);
    return EXIT_FAILURE;
  }
  else
  {
    char c;
    while ((c = getc(file_p)) != EOF)
    {
      write(1, &c, 1);
    }
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xcce(%rip), %rdi       # 0x2004
leaq 0xcd2(%rip), %rsi       # 0x200f
callq 0x1206
testq %rax, %rax
je 0x1392
movq %rax, %rbx
leaq 0x7(%rsp), %r14
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
testl %eax, %eax
jle 0x136a
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb (%rax), %al
jmp 0x1372
movq %rbx, %rdi
callq 0x118c
movb %al, 0x7(%rsp)
cmpb $-0x1, %al
je 0x138e
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1030
jmp 0x134f
xorl %ebx, %ebx
jmp 0x13ad
leaq 0xc78(%rip), %rsi       # 0x2011
movl $0x1, %ebx
movl $0x21, %edx
movl $0x1, %edi
callq 0x1030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/simh[P]simtools/extracters/rawtap/rawtap.c
// Function: usage
void usage(void)
{
  fprintf(stderr, "Usage: rawtap -cae container [-r len] [...]\n\n");
  fprintf(stderr,
          "   Create new container and append file(s):\n");
  fprintf(stderr,
          "     rawtap -c container [-r len] file ...\n\n");
  fprintf(stderr,
          "   Append file(s) to an existing container:\n");
  fprintf(stderr,
          "     rawtap -a container [-r len] file ...\n\n");
  fprintf(stderr,
          "   Extract files from container(s):\n");
  fprintf(stderr,
          "     rawtap -e container ...\n");
  fprintf(stderr,
          "       - Extracted files will be name 00001.dat, 00002.dat etc\n\n");
  fprintf(stderr,
          "\nSwitches:\n\n");
  fprintf(stderr,
          "-r len     - Specify max tape record size (%u <= len <= %u)\n",
          MINRECLEN, MAXRECLEN);
  fprintf(stderr,
          "             The record size applies to all following files and\n");
  fprintf(stderr,
          "             there may be several \"-r nnn\" present on the command line.\n");
  fprintf(stderr,
          "             The default record size is 10240 bytes.\n\n");
  exit(1);
}

// Assembly:
pushq %rbx
movq 0x2c94(%rip), %rbx      # 0x3ff8
movq (%rbx), %rcx
leaq 0xc96(%rip), %rdi       # 0x2004
movl $0x2d, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0xcab(%rip), %rdi       # 0x2032
movl $0x2c, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0xcbf(%rip), %rdi       # 0x205f
movl $0x2c, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0xcd3(%rip), %rdi       # 0x208c
movl $0x2c, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0xce7(%rip), %rdi       # 0x20b9
movl $0x2c, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0xcfb(%rip), %rdi       # 0x20e6
movl $0x24, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0xd07(%rip), %rdi       # 0x210b
movl $0x1d, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0xd0c(%rip), %rdi       # 0x2129
movl $0x40, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0xd34(%rip), %rdi       # 0x216a
movl $0xc, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rdi
leaq 0xd28(%rip), %rsi       # 0x2177
movl $0x1, %edx
movl $0x10000, %ecx          # imm = 0x10000
xorl %eax, %eax
callq 0x10a0
movq (%rbx), %rcx
leaq 0xd4a(%rip), %rdi       # 0x21b4
movl $0x40, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0xd72(%rip), %rdi       # 0x21f5
movl $0x48, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0xda2(%rip), %rdi       # 0x223e
movl $0x36, %esi
movl $0x1, %edx
callq 0x1130
movl $0x1, %edi
callq 0x1120
// File: /workspace/github_c_makefile_star2_O1/simh[P]simtools/extracters/rawtap/tapeio.c
// Function: OpenTapeForRead
int OpenTapeForRead(
  char *name
)
{
  if ((tfile = fopen(name, "rb")) != NULL) {
    int status;

    status = verifyFormat();
    rewind(tfile);
    if ((status != TIO_SUCCESS) && (status != TIO_ERROR))
      CloseTape();
    return status;
  }
  return TIO_OPENFAIL;
}

// Assembly:
pushq %rbx
leaq 0x9d8(%rip), %rsi       # 0x2288
callq 0x1100
movq %rax, 0x12824(%rip)     # 0x140e0
testq %rax, %rax
je 0x18fb
callq 0x1904
movl %eax, %ebx
movq 0x12811(%rip), %rdi     # 0x140e0
callq 0x1080
movl %ebx, %eax
decl %eax
cmpl $-0x3, %eax
ja 0x1900
movq 0x127fc(%rip), %rdi     # 0x140e0
testq %rdi, %rdi
je 0x18ee
callq 0x1070
movq $0x0, 0x127e7(%rip) # 0x140e0
jmp 0x1900
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/marcespie[P]random_run/rr.C
// Function: add_regex(std::vector<std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>>, std::allocator<std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>>>>&, char const*, options const&)
void
add_regex(vector<regex>& v, const char* arg, const options& o)
{
	try {
		using namespace std::regex_constants;
		auto flags = o.eregex ? extended : basic;
		if (o.nocase)
			flags |= icase;
		v.emplace_back(arg, flags);
	} catch (regex_error& e) {
		cerr << "Bad regex " << arg << ": " << e.what() << "\n";
		usage();
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movzbl 0x8(%rdx), %eax
shll $0x5, %eax
addl $0x20, %eax
movl %eax, 0xc(%rsp)
cmpb $0x1, 0x7(%rdx)
jne 0x5d98
orl $0x1, %eax
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x6d2a
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x5e3b
movq %rbx, %rdi
callq 0x5160
movq %rax, %rbx
movq 0x1c21b(%rip), %rdi     # 0x21fe8
leaq 0x1246c(%rip), %rsi     # 0x18240
movl $0xa, %edx
callq 0x5410
movq 0x10(%rsp), %rsi
movq 0x1c1fe(%rip), %rdi     # 0x21fe8
callq 0x5370
movq %rax, %r14
leaq 0x123c4(%rip), %rsi     # 0x181bd
movl $0x2, %edx
movq %rax, %rdi
callq 0x5410
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x5370
leaq 0x1262b(%rip), %rsi     # 0x1844c
movl $0x1, %edx
movq %rax, %rdi
callq 0x5410
callq 0x5ccc
movq %rax, %rbx
callq 0x5530
movq %rbx, %rdi
callq 0x5590
movq %rax, %rdi
callq 0x6d67
// File: /workspace/github_c_makefile_star2_O1/marcespie[P]random_run/rr.C
// Function: compute_maxsize(char**, unsigned long)
size_t
compute_maxsize(char* envp[], size_t margin)
{
	// maxargs for the shell, - path lookup for argv[0]
	auto maxsize = static_cast<size_t>(
	    sysconf(_SC_ARG_MAX) - pathconf("/", _PC_PATH_MAX));

	// need to take envp into account
	for (int i = 0; envp[i] != NULL; ++i)
		maxsize -= strlen(envp[i])+1;
	return maxsize - margin;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
xorl %edi, %edi
callq 0x5250
movq %rax, %r14
leaq 0x123e4(%rip), %rdi     # 0x1824b
movl $0x4, %esi
callq 0x5510
subq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0x5e97
addq $0x8, %r15
callq 0x5180
notq %rax
addq %rax, %r14
movq (%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x5e80
subq %rbx, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/marcespie[P]random_run/rr.C
// Function: add_lines_from(std::vector<std::filesystem::__cxx11::path, std::allocator<std::filesystem::__cxx11::path>>&, std::istream&, char const*)
const char *fname)
{
	for (string line; getline(f, line); )
		r.emplace_back(line);
	if (f.bad()) {
		auto e = strerror(errno);
		cerr << "Error while reading " << fname << ": " << e << "\n";
		exit(1);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq %rsp, %r12
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x55d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x61bb
movq %r15, %rdi
movq %r12, %rsi
callq 0x7070
jmp 0x617e
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x61d1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5390
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x1, 0x20(%r14,%rax)
jne 0x61ee
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5060
movl (%rax), %edi
callq 0x5110
movq %rax, %r14
movq 0x1bde4(%rip), %rdi     # 0x21fe8
leaq 0x1205f(%rip), %rsi     # 0x1826a
callq 0x5370
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5370
leaq 0x11f9b(%rip), %rsi     # 0x181bd
movq %rax, %rdi
callq 0x5370
movq %rax, %rdi
movq %r14, %rsi
callq 0x5370
leaq 0x12210(%rip), %rsi     # 0x1844c
movq %rax, %rdi
callq 0x5370
movl $0x1, %edi
callq 0x5450
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6267
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5590
// File: /workspace/github_c_makefile_star2_O1/marcespie[P]random_run/rr.C
// Function: add_lines(std::vector<std::filesystem::__cxx11::path, std::allocator<std::filesystem::__cxx11::path>>&, char const*)
void
add_lines(vector<path>& r, const char* fname)
{
	if (strcmp(fname, "-") == 0) {
		add_lines_from(r, cin, fname);
	} else {
		if (is_directory(fname)) {
			cerr << "Can't read directory: " << fname << "\n";
			exit(1);
		}
		ifstream f;
		f.open(fname);
		if (!f.good()) {
			auto e = strerror(errno);
			cerr << "Failed to open " << fname << ": " << e << "\n";
			exit(1);
		}
		add_lines_from(r, f, fname);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x120a2(%rip), %rsi     # 0x1832d
movq %r14, %rdi
callq 0x54a0
testl %eax, %eax
je 0x6323
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0x2, %edx
callq 0x70aa
movq %r14, %rdi
callq 0x5150
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7132
cmpb $0x2, %r14b
je 0x633f
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x5400
movq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x5220
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x30(%rsp,%rax)
jne 0x6378
movq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x614f
leaq 0x10(%rsp), %rdi
callq 0x5090
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
movq 0x1bca6(%rip), %rsi     # 0x21fd0
movq %rbx, %rdi
movq %r14, %rdx
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
jmp 0x614f
movq 0x1bca2(%rip), %rdi     # 0x21fe8
leaq 0x11f32(%rip), %rsi     # 0x1827f
callq 0x5370
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x5370
leaq 0x120e6(%rip), %rsi     # 0x1844c
movq %rax, %rdi
callq 0x5370
movl $0x1, %edi
callq 0x5450
callq 0x5060
movl (%rax), %edi
callq 0x5110
movq %rax, %rbx
movq 0x1bc5a(%rip), %rdi     # 0x21fe8
leaq 0x11f01(%rip), %rsi     # 0x18296
movl $0xf, %edx
callq 0x5410
movq 0x8(%rsp), %rsi
movq 0x1bc3d(%rip), %rdi     # 0x21fe8
callq 0x5370
movq %rax, %r14
leaq 0x11e03(%rip), %rsi     # 0x181bd
movl $0x2, %edx
movq %rax, %rdi
callq 0x5410
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5370
leaq 0x12073(%rip), %rsi     # 0x1844c
movq %rax, %rdi
callq 0x5370
jmp 0x636e
jmp 0x63f4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7132
jmp 0x6401
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5090
movq %rbx, %rdi
callq 0x5590
// File: /workspace/github_c_makefile_star2_O1/marcespie[P]random_run/rr.C
// Function: exec(std::vector<char const*, std::allocator<char const*>> const&)
void
exec(const vector<const char*>& v)
{
	// XXX paths are essentially "movable" strings, so they're const
	// let's type-pune the const, we won't ever return anyway
	execvp(v[0], const_cast<char**>(v.data()));
	string k = "can't exec ";
	k += v[0];
	system_error(k.c_str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
movq (%rsi), %rdi
callq 0x52c0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x11dc8(%rip), %rsi     # 0x182a6
leaq 0x11dcc(%rip), %rdx     # 0x182b1
movq %rsp, %r14
movq %r14, %rdi
callq 0x800e
movq (%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x5630
movq (%rsp), %rdi
callq 0x5d08
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6520
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5590
// File: /workspace/github_c_makefile_star2_O1/marcespie[P]random_run/rr.C
// Function: deal_with_child(int, bool)
void
deal_with_child(int pid, bool exitonerror)
{
	int r;
	auto e = waitpid(pid, &r, 0);
	if (e == -1)
		system_error("waitpid");
	if (e != pid) {
		cerr << "waitpid exited with " << e << 
		    "(shouldn't happen)\n";
		exit(1);
	}
		
	if (WIFEXITED(r)) {
		auto s = WEXITSTATUS(r);
		if (s != 0) {
			cerr << "Command exited with "<< s << "\n";
			if (exitonerror)
				exit(s);
		}
	} else {
		auto s = WTERMSIG(r);
		cerr << "Command exited on signal #"<< s << "\n";
		if (exitonerror) {
			kill(getpid(), s);
			// in case we didn't die
			exit(1);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
leaq 0x4(%rsp), %rsi
xorl %edx, %edx
callq 0x52f0
cmpl $-0x1, %eax
je 0x6606
movl %eax, %ebp
cmpl %r14d, %eax
jne 0x6612
movl 0x4(%rsp), %ebp
movl %ebp, %r14d
andl $0x7f, %r14d
je 0x65b3
movq 0x1ba80(%rip), %r15     # 0x21fe8
leaq 0x11d89(%rip), %rsi     # 0x182f8
movl $0x1a, %edx
movq %r15, %rdi
callq 0x5410
movq %r15, %rdi
movl %r14d, %esi
callq 0x5580
leaq 0x11ebe(%rip), %rsi     # 0x1844c
movl $0x1, %edx
movq %rax, %rdi
callq 0x5410
testb %bl, %bl
je 0x65fb
callq 0x54f0
movl %eax, %edi
movl %r14d, %esi
callq 0x54c0
jmp 0x663e
shrl $0x8, %ebp
andl $0xff, %ebp
je 0x65fb
movq 0x1ba23(%rip), %r14     # 0x21fe8
leaq 0x11d17(%rip), %rsi     # 0x182e3
movl $0x14, %edx
movq %r14, %rdi
callq 0x5410
movq %r14, %rdi
movl %ebp, %esi
callq 0x5580
leaq 0x11e62(%rip), %rsi     # 0x1844c
movl $0x1, %edx
movq %rax, %rdi
callq 0x5410
testb %bl, %bl
jne 0x6648
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11ca5(%rip), %rdi     # 0x182b2
callq 0x5d08
movq 0x1b9cf(%rip), %rdi     # 0x21fe8
leaq 0x11c9a(%rip), %rsi     # 0x182ba
callq 0x5370
movq %rax, %rdi
movl %ebp, %esi
callq 0x5580
leaq 0x11c99(%rip), %rsi     # 0x182cf
movq %rax, %rdi
callq 0x5370
movl $0x1, %edi
callq 0x5450
movl %ebp, %edi
callq 0x5450
// File: /workspace/github_c_makefile_star2_O1/marcespie[P]random_run/rr.C
// Function: keep(char const*, options const&)
bool
keep(const char* s, const options& o)
{
	// notice the asymetry: we "exclude" anything
	if (any_match(s, o.exclude))
		return false;
	// BUT "only" doesn't kick in if it's not been mentioned
	return o.only.size() == 0 || any_match(s, o.only);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x50, %rsi
callq 0x6409
testb %al, %al
je 0x666a
xorl %eax, %eax
jmp 0x668c
movq 0x70(%rbx), %rax
cmpq 0x68(%rbx), %rax
je 0x668a
addq $0x68, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6409
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/acorn128v2/opt/encrypt.c
// Function: acorn128_initialization_32bitversion
void acorn128_initialization_32bitversion(const unsigned char *key, const unsigned char *iv, unsigned long long *state)
{
        int i, j;
        unsigned int m;
        unsigned int ks=0, tem=0;

        //initialize the state to 0
        for (j = 0; j <= 6; j++) state[j] = 0;

        //run the cipher for 1792 steps
        for (j = 0;  j <= 3;  j++)
        {
            encrypt_32bits(state, ((unsigned int*)key)[j], &tem, &ks, 0xffffffff, 0xffffffff);
        }
        for (j = 4;  j <= 7;  j++)
        {
            encrypt_32bits(state, ((unsigned int*)iv)[j-4], &tem, &ks, 0xffffffff, 0xffffffff);
        }
        for (j = 8;  j <= 8; j++)
        {
            encrypt_32bits(state, ((unsigned int*)key)[j&3] ^ 1, &tem, &ks, 0xffffffff, 0xffffffff);
        }
        for (j = 9;  j <= 55; j++)
        {
            encrypt_32bits(state, ((unsigned int*)key)[j&3], &tem, &ks, 0xffffffff, 0xffffffff);
        }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
movl %ebp, (%r12)
movq %rsp, %r13
movl %ebp, (%r13)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x18(%rdx)
vmovups %ymm0, (%rdx)
movl (%r14,%rbp,4), %esi
movq %rbx, %rdi
movq %r13, %rdx
movq %r12, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
vzeroupper
callq 0x10b0
incq %rbp
cmpq $0x4, %rbp
jne 0x1778
xorl %ebp, %ebp
movq %rsp, %r12
leaq 0x4(%rsp), %r13
movl (%r15,%rbp,4), %esi
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0x10b0
incq %rbp
cmpq $0x4, %rbp
jne 0x17ac
movl (%r14), %esi
xorl $0x1, %esi
movq %rsp, %r15
leaq 0x4(%rsp), %r12
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0x10b0
movl $0x9, %ebp
movl %ebp, %eax
andl $0x3, %eax
movl (%r14,%rax,4), %esi
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0x10b0
incl %ebp
cmpl $0x38, %ebp
jne 0x1800
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/acorn128v2/opt/encrypt.c
// Function: acorn128_tag_generation_32bits_version
void acorn128_tag_generation_32bits_version(unsigned long long msglen, unsigned long long adlen, unsigned char maclen, unsigned char *mac, unsigned long long *state)
{
    int i;
    unsigned int plaintextword  = 0;
    unsigned int ciphertextword = 0;
    unsigned int ksword = 0;

    for (i = 0; i < 768/32; i++)
    {
        encrypt_32bits(state, plaintextword, &ciphertextword, &ksword, 0xffffffff, 0xffffffff);
        if ( i >= (768/32 - 4) ) { ((unsigned int*)mac)[i-(768/32-4)] = ksword; }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r14
xorl %r13d, %r13d
leaq 0xc(%rsp), %r15
movl %r13d, (%r15)
leaq 0x8(%rsp), %r12
movl %r13d, (%r12)
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0x10b0
cmpq $0x14, %r13
jb 0x188b
movl 0x8(%rsp), %eax
movl %eax, -0x50(%r14,%r13,4)
incq %r13
cmpq $0x18, %r13
jne 0x1860
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_var.c
// Function: pkGetValueType
PkVarType pkGetValueType(const PkVar value) {
  __ASSERT(value != NULL, "Given value was NULL.");

  if (IS_NULL(*(const Var*)(value))) return PK_NULL;
  if (IS_BOOL(*(const Var*)(value))) return PK_BOOL;
  if (IS_NUM(*(const Var*)(value))) return PK_NUMBER;

  __ASSERT(IS_OBJ(*(const Var*)(value)),
           "Invalid var pointer. Might be a dangling pointer");

  const Object* obj = AS_OBJ(*(const Var*)(value));
  switch (obj->type) {
    case OBJ_STRING: return PK_STRING;
    case OBJ_LIST:   return PK_LIST;
    case OBJ_MAP:    return PK_MAP;
    case OBJ_RANGE:  return PK_RANGE;
    case OBJ_SCRIPT: return PK_SCRIPT;
    case OBJ_FUNC:   return PK_FUNCTION;
    case OBJ_FIBER:  return PK_FIBER;
    case OBJ_CLASS:  return PK_CLASS;
    case OBJ_INST:   return PK_INST;
  }

  UNREACHABLE();
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x7f57
movq (%rdi), %rcx
movabsq $-0x7ffd000000000002, %rax # imm = 0x8002FFFFFFFFFFFE
addq %rcx, %rax
cmpq $0x2, %rax
jae 0x7f0f
movl $0x1, %eax
jmp 0x7f55
xorl %eax, %eax
movabsq $0x7ffc000000000000, %rdx # imm = 0x7FFC000000000000
cmpq %rdx, %rcx
je 0x7f55
movq %rcx, %rsi
notq %rsi
movl $0x2, %eax
testq %rdx, %rsi
jne 0x7f55
movq %rcx, %rax
shrq $0x32, %rax
cmpl $0x3ffe, %eax           # imm = 0x3FFE
jbe 0x7f5c
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %rcx
movl (%rcx), %eax
cmpl $0x9, %eax
jae 0x7f61
addl $0x3, %eax
popq %rcx
retq
callq 0x2441
callq 0x23e0
callq 0x2414
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_var.c
// Function: pkNewString
PkHandle* pkNewString(PKVM* vm, const char* value) {
  String* str = newString(vm, value);
  vmPushTempRef(vm, &str->_super); // str
  PkHandle* handle = vmNewHandle(vm, VAR_OBJ(str));
  vmPopTempRef(vm); // str
  return handle;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x7f82
movq %r14, %rdi
callq 0x2140
movq %rax, %rdx
jmp 0x7f84
xorl %edx, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7fc8
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb8d6
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %r14, %rsi
movq %rbx, %rdi
callq 0xb6ca
movq %rax, %r14
movq %rbx, %rdi
callq 0xb949
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq