LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9995
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x94(%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jle 0x9977
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
je 0x98d2
jmp 0x995d
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x994e
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
je 0x9907
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x994e
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x88(%rcx), %rcx
movq -0x20(%rbp), %rdx
movl 0x94(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl 0x94(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x94(%rax)
jmp 0x995b
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x8(%rax)
jmp 0x9985
movq -0x28(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x98b8
leaq 0x2928(%rip), %rdi      # 0xc2a6
movb $0x0, %al
callq 0x3130
jmp 0x9987
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9882
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x11a7
movq 0x2e68(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xe66(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1040
jmp 0x11ee
cmpq $0x1, -0x18(%rbp)
jbe 0x11d0
movq 0x2e43(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0xe52(%rip), %rsi       # 0x2019
movb $0x0, %al
callq 0x1040
jmp 0x11ec
movq 0x2e21(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xe5d(%rip), %rsi       # 0x2042
movb $0x0, %al
callq 0x1040
jmp 0x11ee
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2dba(%rip), %rax      # 0x3fd0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1050
movq 0x2dad(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1050
movq 0x2d98(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1030
movl %eax, -0x10(%rbp)
movq 0x2d86(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1060
movl -0x10(%rbp), %esi
movq %rax, %rdx
leaq 0xded(%rip), %rdi       # 0x2054
callq 0x1170
movq 0x2d5d(%rip), %rax      # 0x3fd0
movq (%rax), %rdi
callq 0x1030
movl %eax, -0xc(%rbp)
movq 0x2d4b(%rip), %rax      # 0x3fd0
movq (%rax), %rdi
callq 0x1060
movl -0xc(%rbp), %esi
movq %rax, %rdx
leaq 0xdc0(%rip), %rdi       # 0x205a
callq 0x1170
movq 0x2d52(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
callq 0x1030
movl %eax, -0x8(%rbp)
movq 0x2d40(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
callq 0x1060
movl -0x8(%rbp), %esi
movq %rax, %rdx
leaq 0xd94(%rip), %rdi       # 0x2061
callq 0x1170
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x30b6(%rip), %rdi      # 0x61a0
xorl %esi, %esi
movb $0x0, %al
callq 0x2200
movl %eax, -0x1014(%rbp)
callq 0x2280
cltq
imulq -0x10(%rbp), %rax
movq %rax, -0x1020(%rbp)
cmpl $0x0, -0x1014(%rbp)
jl 0x3117
jmp 0x3136
leaq 0x116f(%rip), %rdi      # 0x428d
leaq 0x1170(%rip), %rsi      # 0x4295
movl $0x25, %edx
leaq 0x119e(%rip), %rcx      # 0x42cf
callq 0x2110
jmp 0x3138
movl -0x1014(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movq -0x1020(%rbp), %rcx
movl $0x1000, %edx           # imm = 0x1000
callq 0x2260
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x3160
jmp 0x317f
leaq 0x119b(%rip), %rdi      # 0x4302
leaq 0x1127(%rip), %rsi      # 0x4295
movl $0x28, %edx
leaq 0x1155(%rip), %rcx      # 0x42cf
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3138
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6670
movb $0x1, -0x1(%rbp)
jmp 0x67a4
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x66e8
xorl %eax, %eax
testb $0x1, -0x19(%rbp)
movb %al, -0x1a(%rbp)
je 0x66e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
jge 0x66e0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x63c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
setl %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x675f
xorl %eax, %eax
testb $0x1, -0x19(%rbp)
movb %al, -0x29(%rbp)
je 0x6757
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
jle 0x6757
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6350
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq 0x10(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
setg %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
xorl %eax, %eax
testb $0x1, -0x19(%rbp)
movb %al, -0x39(%rbp)
je 0x679c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6650
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0x6788
jmp 0x679c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6650
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBinarySearchTree/ADTSet.c
// Function: node_create
static SetNode node_create(Pointer value) {
	SetNode node = malloc(sizeof(*node));
	node->left = NULL;
	node->right = NULL;
	node->value = value;
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x2180
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6833
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6855
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6800
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x31, %eax
je 0x18b5
jmp 0x17fd
movl -0x14(%rbp), %eax
subl $0x49, %eax
je 0x186b
jmp 0x1807
movl -0x14(%rbp), %eax
subl $0x6c, %eax
jne 0x18ec
jmp 0x1815
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x31, %eax
je 0x1853
jmp 0x1827
movl -0x18(%rbp), %eax
subl $0x49, %eax
je 0x1847
jmp 0x1831
movl -0x18(%rbp), %eax
subl $0x6c, %eax
jne 0x185f
jmp 0x183b
movl $0x0, -0x4(%rbp)
jmp 0x18f3
movl $0x1, -0x4(%rbp)
jmp 0x18f3
movl $0x6, -0x4(%rbp)
jmp 0x18f3
movl $0x8, -0x4(%rbp)
jmp 0x18f3
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x31, %eax
je 0x18a3
jmp 0x187d
movl -0x1c(%rbp), %eax
subl $0x49, %eax
je 0x189a
jmp 0x1887
movl -0x1c(%rbp), %eax
subl $0x6c, %eax
jne 0x18ac
jmp 0x1891
movl $0x2, -0x4(%rbp)
jmp 0x18f3
movl $0x3, -0x4(%rbp)
jmp 0x18f3
movl $0x7, -0x4(%rbp)
jmp 0x18f3
movl $0x8, -0x4(%rbp)
jmp 0x18f3
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x49, %eax
je 0x18da
jmp 0x18c7
movl -0x20(%rbp), %eax
subl $0x6c, %eax
jne 0x18e3
jmp 0x18d1
movl $0x4, -0x4(%rbp)
jmp 0x18f3
movl $0x5, -0x4(%rbp)
jmp 0x18f3
movl $0x8, -0x4(%rbp)
jmp 0x18f3
movl $0x8, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xb1e(%rip), %rdi       # 0x2004
leaq 0xb22(%rip), %rsi       # 0x200f
callq 0x12e0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x151b
movl $0x1, %edi
leaq 0xb09(%rip), %rsi       # 0x2011
movl $0x21, %edx
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x1580
jmp 0x151d
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jl 0x1548
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x1554
movq -0x10(%rbp), %rdi
callq 0x1190
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x1577
movl $0x1, %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x1030
jmp 0x151d
jmp 0x1579
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0x3d9d(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1d9f(%rip), %rsi      # 0x3004
movb $0x0, %al
callq 0x10a0
movq 0x3d85(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1db5(%rip), %rsi      # 0x3032
movb $0x0, %al
callq 0x10a0
movq 0x3d6d(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1dca(%rip), %rsi      # 0x305f
movb $0x0, %al
callq 0x10a0
movq 0x3d55(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1ddf(%rip), %rsi      # 0x308c
movb $0x0, %al
callq 0x10a0
movq 0x3d3d(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1df4(%rip), %rsi      # 0x30b9
movb $0x0, %al
callq 0x10a0
movq 0x3d25(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1e09(%rip), %rsi      # 0x30e6
movb $0x0, %al
callq 0x10a0
movq 0x3d0d(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1e16(%rip), %rsi      # 0x310b
movb $0x0, %al
callq 0x10a0
movq 0x3cf5(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1e1c(%rip), %rsi      # 0x3129
movb $0x0, %al
callq 0x10a0
movq 0x3cdd(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1e45(%rip), %rsi      # 0x316a
movb $0x0, %al
callq 0x10a0
movq 0x3cc5(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1e3a(%rip), %rsi      # 0x3177
movl $0x1, %edx
movl $0x10000, %ecx          # imm = 0x10000
movb $0x0, %al
callq 0x10a0
movq 0x3ca3(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1e55(%rip), %rsi      # 0x31b4
movb $0x0, %al
callq 0x10a0
movq 0x3c8b(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1e7e(%rip), %rsi      # 0x31f5
movb $0x0, %al
callq 0x10a0
movq 0x3c73(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1eaf(%rip), %rsi      # 0x323e
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1120
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x18a1(%rip), %rsi      # 0x3288
callq 0x1100
movq %rax, 0x136ed(%rip)     # 0x150e0
cmpq $0x0, %rax
je 0x1a26
callq 0x1a40
movl %eax, -0x14(%rbp)
movq 0x136d8(%rip), %rdi     # 0x150e0
callq 0x1080
cmpl $0x0, -0x14(%rbp)
je 0x1a1e
cmpl $-0x1, -0x14(%rbp)
je 0x1a1e
callq 0x1c50
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a2d
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb 0x8(%rax), %dl
movl $0x20, %eax
movl $0x40, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x7(%rax)
je 0x6be4
leaq -0x1c(%rbp), %rdi
movl $0x1, %esi
callq 0x83c0
jmp 0x6b3c
jmp 0x6be4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6c14
movq -0x28(%rbp), %rdi
callq 0x61c0
movq %rax, -0x38(%rbp)
movq 0x52477(%rip), %rdi     # 0x58fe8
leaq 0x3588c(%rip), %rsi     # 0x3c404
callq 0x64a0
movq %rax, -0x40(%rbp)
jmp 0x6b83
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64a0
movq %rax, -0x48(%rbp)
jmp 0x6b96
movq -0x48(%rbp), %rdi
leaq 0x357e0(%rip), %rsi     # 0x3c381
callq 0x64a0
movq %rax, -0x50(%rbp)
jmp 0x6bac
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x64a0
movq %rax, -0x58(%rbp)
jmp 0x6bcb
movq -0x58(%rbp), %rdi
leaq 0x35a6d(%rip), %rsi     # 0x3c643
callq 0x64a0
jmp 0x6bdd
callq 0x6a10
jmp 0x6be4
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x83f0
jmp 0x6bf7
jmp 0x6c0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6720
jmp 0x6c0c
jmp 0x6c14
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x67e0
movq %rax, %rdi
callq 0x8470
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %edi, %edi
callq 0x6350
movq %rax, -0x28(%rbp)
leaq 0x357bd(%rip), %rdi     # 0x3c40f
movl $0x4, %esi
callq 0x6700
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x6cae
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6200
movq %rax, %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6c71
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6660
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x60a0
movq %rax, -0x58(%rbp)
jmp 0x7020
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6610
movb %al, -0x59(%rbp)
jmp 0x7038
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x7066
jmp 0x7041
leaq -0x38(%rbp), %rdi
callq 0x62f0
jmp 0x7077
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x62f0
jmp 0x70f6
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8960
jmp 0x7075
jmp 0x700d
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x6810
testb $0x1, %al
jne 0x708d
jmp 0x70f0
callq 0x6070
movl (%rax), %edi
callq 0x6160
movq %rax, -0x50(%rbp)
movq 0x51f44(%rip), %rdi     # 0x58fe8
leaq 0x35383(%rip), %rsi     # 0x3c42e
callq 0x64a0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x64a0
movq %rax, %rdi
leaq 0x352bb(%rip), %rsi     # 0x3c381
callq 0x64a0
movq %rax, %rdi
movq -0x50(%rbp), %rsi
callq 0x64a0
movq %rax, %rdi
leaq 0x35562(%rip), %rsi     # 0x3c643
callq 0x64a0
movl $0x1, %edi
callq 0x65e0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x67e0
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x353f0(%rip), %rsi     # 0x3c50e
callq 0x6680
cmpl $0x0, %eax
jne 0x7141
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq 0x51e99(%rip), %rsi     # 0x58fd0
callq 0x6ff0
jmp 0x730a
leaq -0x38(%rbp), %rdi
movq %rdi, -0x268(%rbp)
leaq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x8a10
movq -0x268(%rbp), %rdi
callq 0x89e0
movb %al, -0x259(%rbp)
jmp 0x716e
leaq -0x38(%rbp), %rdi
callq 0x8af0
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x7183
jmp 0x71d5
movq 0x51e5e(%rip), %rdi     # 0x58fe8
leaq 0x352b2(%rip), %rsi     # 0x3c443
callq 0x64a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x64a0
movq %rax, %rdi
leaq 0x35497(%rip), %rsi     # 0x3c643
callq 0x64a0
movl $0x1, %edi
callq 0x65e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8af0
jmp 0x7313
leaq -0x250(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0x6590
movq -0x270(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x6320
jmp 0x71ff
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x250(%rbp,%rax), %rdi
callq 0x6790
movb %al, -0x271(%rbp)
jmp 0x721f
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x72e8
jmp 0x722f
callq 0x6070
movl (%rax), %edi
callq 0x6160
movq %rax, -0x258(%rbp)
movq 0x51d9f(%rip), %rdi     # 0x58fe8
leaq 0x3520a(%rip), %rsi     # 0x3c45a
callq 0x64a0
movq %rax, -0x280(%rbp)
jmp 0x725e
movq -0x280(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64a0
movq %rax, -0x288(%rbp)
jmp 0x7277
movq -0x288(%rbp), %rdi
leaq 0x350fc(%rip), %rsi     # 0x3c381
callq 0x64a0
movq %rax, -0x290(%rbp)
jmp 0x7293
movq -0x290(%rbp), %rdi
movq -0x258(%rbp), %rsi
callq 0x64a0
movq %rax, -0x298(%rbp)
jmp 0x72af
movq -0x298(%rbp), %rdi
leaq 0x35386(%rip), %rsi     # 0x3c643
callq 0x64a0
jmp 0x72c4
movl $0x1, %edi
callq 0x65e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x60e0
jmp 0x7313
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x250(%rbp), %rsi
callq 0x6ff0
jmp 0x72fe
leaq -0x250(%rbp), %rdi
callq 0x60e0
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x67e0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/marcespie[P]random_run/rr.C
// Function: any_match(char const*, std::vector<std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>>, std::allocator<std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>>>> const&)
bool 
any_match(const char* s, const vector<regex>& x)
{
	for (auto& r: x)
		if (regex_match(s, r))
			return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8b20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8b50
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8b80
testb $0x1, %al
jne 0x7365
jmp 0x739a
leaq -0x28(%rbp), %rdi
callq 0x8bc0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x8be0
testb $0x1, %al
jne 0x7387
jmp 0x738d
movb $0x1, -0x1(%rbp)
jmp 0x739e
jmp 0x738f
leaq -0x28(%rbp), %rdi
callq 0x8c30
jmp 0x7352
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8c50
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8c70
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x63c0
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x67f0
movq -0x48(%rbp), %rdx
leaq 0x3506d(%rip), %rsi     # 0x3c46a
leaq -0x28(%rbp), %rdi
callq 0x8c90
jmp 0x7408
leaq -0x29(%rbp), %rdi
callq 0x6510
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8c50
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x6490
jmp 0x742c
leaq -0x28(%rbp), %rdi
callq 0x61d0
movq %rax, %rdi
callq 0x6a50
jmp 0x743f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x6510
jmp 0x746b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x62f0
movq -0x38(%rbp), %rdi
callq 0x67e0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
movl -0x4(%rbp), %edi
leaq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x63f0
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
jne 0x74b6
leaq 0x34fc5(%rip), %rdi     # 0x3c476
callq 0x6a50
movl -0x10(%rbp), %eax
cmpl -0x4(%rbp), %eax
je 0x74f5
movq 0x51b23(%rip), %rdi     # 0x58fe8
leaq 0x34fb2(%rip), %rsi     # 0x3c47e
callq 0x64a0
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x67c0
movq %rax, %rdi
leaq 0x34fad(%rip), %rsi     # 0x3c493
callq 0x64a0
movl $0x1, %edi
callq 0x65e0
movl -0xc(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x7553
movl -0xc(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x7551
movq 0x51acd(%rip), %rdi     # 0x58fe8
leaq 0x34f85(%rip), %rsi     # 0x3c4a7
callq 0x64a0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x67c0
movq %rax, %rdi
leaq 0x35107(%rip), %rsi     # 0x3c643
callq 0x64a0
testb $0x1, -0x5(%rbp)
je 0x754f
movl -0x14(%rbp), %edi
callq 0x65e0
jmp 0x7551
jmp 0x75aa
movl -0xc(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x18(%rbp)
movq 0x51a85(%rip), %rdi     # 0x58fe8
leaq 0x34f52(%rip), %rsi     # 0x3c4bc
callq 0x64a0
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x67c0
movq %rax, %rdi
leaq 0x350bf(%rip), %rsi     # 0x3c643
callq 0x64a0
testb $0x1, -0x5(%rbp)
je 0x75a8
callq 0x66e0
movl %eax, %edi
movl -0x18(%rbp), %esi
callq 0x66a0
movl $0x1, %edi
callq 0x65e0
jmp 0x75aa
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x50, %rsi
callq 0x7320
testb $0x1, %al
jne 0x75d7
jmp 0x75dd
movb $0x0, -0x1(%rbp)
jmp 0x7614
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x8d40
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
je 0x760c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x68, %rsi
callq 0x7320
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x6, 0x18(%rsp)
jg 0x21f1
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x21cb
movl $0x0, 0x18(%rsp)
cmpl $0x3, 0x18(%rsp)
jg 0x2237
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movslq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movl %r9d, %r8d
callq 0x10b0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x21f9
movl $0x4, 0x18(%rsp)
cmpl $0x7, 0x18(%rsp)
jg 0x2282
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x18(%rsp), %ecx
subl $0x4, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %esi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movl %r9d, %r8d
callq 0x10b0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x223f
movl $0x8, 0x18(%rsp)
cmpl $0x8, 0x18(%rsp)
jg 0x22d0
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x18(%rsp), %ecx
andl $0x3, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %esi
xorl $0x1, %esi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movl %r9d, %r8d
callq 0x10b0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x228a
movl $0x9, 0x18(%rsp)
cmpl $0x37, 0x18(%rsp)
jg 0x231b
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x18(%rsp), %ecx
andl $0x3, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %esi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movl %r9d, %r8d
callq 0x10b0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x22d8
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x0, (%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x18, 0xc(%rsp)
jge 0x23ae
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
leaq 0x4(%rsp), %rdx
movq %rsp, %rcx
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movl %r9d, %r8d
callq 0x10b0
cmpl $0x14, 0xc(%rsp)
jl 0x239f
movl (%rsp), %edx
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
subl $0x14, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x23a1
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x235d
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x26f2
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x2700
movq 0x28(%rsp), %rdi
callq 0x2130
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %edx
callq 0x2760
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x9420
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x9080
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x95c0
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: newStringLength
String* newStringLength(PKVM* vm, const char* text, uint32_t length) {

  ASSERT(length == 0 || text != NULL, "Unexpected NULL string.");

  String* string = _allocateString(vm, length);

  if (length != 0 && text != NULL) memcpy(string->data, text, length);
  string->hash = utilHashString(string->data);

  return string;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x27bb
cmpq $0x0, 0x18(%rsp)
jne 0x27bb
movq 0x30870(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x279be(%rip), %rsi     # 0x2a150
leaq 0x27aa3(%rip), %rdx     # 0x2a23c
leaq 0x27ab4(%rip), %rcx     # 0x2a254
leaq 0x279f5(%rip), %r8      # 0x2a19c
movl $0x14a, %r9d            # imm = 0x14A
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x27bd
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x45e0
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x27fa
cmpq $0x0, 0x18(%rsp)
je 0x27fa
movq 0x8(%rsp), %rdi
addq $0x1c, %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %eax
movl %eax, %edx
callq 0x2270
movq 0x8(%rsp), %rdi
addq $0x1c, %rdi
callq 0x140c0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: pkNewStringLength
PkHandle* pkNewStringLength(PKVM* vm, const char* value, size_t len) {
  String* str = newStringLength(vm, value, (uint32_t)len);
  vmPushTempRef(vm, &str->_super); // str
  PkHandle* handle = vmNewHandle(vm, VAR_OBJ(str));
  vmPopTempRef(vm); // str
  return handle;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movl %eax, %edx
callq 0x2760
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9420
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x9080
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x95c0
movq (%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: pkNewList
PkHandle* pkNewList(PKVM* vm) {
  List* list = newList(vm, MIN_CAPACITY);
  vmPushTempRef(vm, &list->_super); // list
  PkHandle* handle = vmNewHandle(vm, VAR_OBJ(list));
  vmPopTempRef(vm); // list
  return handle;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x28f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9420
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x9080
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x95c0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: newList
List* newList(PKVM* vm, uint32_t size) {
  List* list = ALLOCATE(vm, List);
  vmPushTempRef(vm, &list->_super);
  varInitObject(&list->_super, vm, OBJ_LIST);
  pkVarBufferInit(&list->elements);
  if (size > 0) {
    pkVarBufferFill(&list->elements, vm, VAR_NULL, size);
    list->elements.count = 0;
  }
  vmPopTempRef(vm);
  return list;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x20, %ecx
movq %rdx, %rsi
callq 0x8f90
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x9420
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x3d00
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x3330
cmpl $0x0, 0xc(%rsp)
jbe 0x2977
movq (%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %ecx
movabsq $0x7ffc000000000000, %rdx # imm = 0x7FFC000000000000
callq 0x3450
movq (%rsp), %rax
movl $0x0, 0x18(%rax)
movq 0x10(%rsp), %rdi
callq 0x95c0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: pkNewMap
PkHandle* pkNewMap(PKVM* vm) {
  Map* map = newMap(vm);
  vmPushTempRef(vm, &map->_super); // map
  PkHandle* handle = vmNewHandle(vm, VAR_OBJ(map));
  vmPopTempRef(vm); // map
  return handle;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x29f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9420
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x9080
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x95c0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: newMap
Map* newMap(PKVM* vm) {
  Map* map = ALLOCATE(vm, Map);
  varInitObject(&map->_super, vm, OBJ_MAP);
  map->capacity = 0;
  map->count = 0;
  map->entries = NULL;
  return map;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x20, %ecx
movq %rdx, %rsi
callq 0x8f90
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x2, %edx
callq 0x3d00
movq 0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x14(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: pkNewFiber
PkHandle* pkNewFiber(PKVM* vm, PkHandle* fn) {
  __ASSERT(IS_OBJ_TYPE(fn->value, OBJ_FUNC), "Fn should be of type function.");

  Fiber* fiber = newFiber(vm, (Function*)AS_OBJ(fn->value));
  vmPushTempRef(vm, &fiber->_super); // fiber
  PkHandle* handle = vmNewHandle(vm, VAR_OBJ(fiber));
  vmPopTempRef(vm); // fiber
  return handle;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq (%rcx), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x2aa6
movq 0x18(%rsp), %rcx
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq (%rcx), %rax
cmpl $0x5, (%rax)
je 0x2ae0
movq 0x3054b(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x27699(%rip), %rsi     # 0x2a150
leaq 0x27754(%rip), %rdx     # 0x2a212
leaq 0x2776c(%rip), %rcx     # 0x2a231
leaq 0x276d0(%rip), %r8      # 0x2a19c
movl $0x4d, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x2ae2
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
andq (%rax), %rsi
callq 0x2b50
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9420
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x9080
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x95c0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: pkNewInstNative
PkHandle* pkNewInstNative(PKVM* vm, void* data, uint32_t id) {
  Instance* inst = newInstanceNative(vm, data, id);
  vmPushTempRef(vm, &inst->_super); // inst
  PkHandle* handle = vmNewHandle(vm, VAR_OBJ(inst));
  vmPopTempRef(vm); // inst
  return handle;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0x2dd0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9420
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x9080
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x95c0
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: newInstanceNative
Instance* newInstanceNative(PKVM* vm, void* data, uint32_t id) {
  Instance* inst = ALLOCATE(vm, Instance);
  varInitObject(&inst->_super, vm, OBJ_INST);
  inst->is_native = true;
  inst->native_id = id;

  if (vm->config.inst_name_fn != NULL) {
    inst->name = vm->config.inst_name_fn(id);
  } else {
    inst->name = "$(?)";
  }

  inst->native = data;
  return inst;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x28, %ecx
movq %rdx, %rsi
callq 0x8f90
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x8, %edx
callq 0x3d00
movq 0x8(%rsp), %rax
movb $0x1, 0x18(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x2e55
movq 0x20(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0x14(%rsp), %edi
callq *%rax
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x2e65
movq 0x8(%rsp), %rax
leaq 0x27454(%rip), %rcx     # 0x2a2b5
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: allocateString
static String* _allocateString(PKVM* vm, size_t length) {
  String* string = ALLOCATE_DYNAMIC(vm, String, length + 1, char);
  varInitObject(&string->_super, vm, OBJ_STRING);
  string->length = (uint32_t)length;
  string->data[length] = '\0';
  string->capacity = (uint32_t)(length + 1);
  return string;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
addq $0x1, %rcx
shlq $0x0, %rcx
addq $0x20, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x8f90
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x3d00
movq 0x8(%rsp), %rax
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x14(%rax)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, 0x1c(%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x18(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)