LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %r14d
leaq 0x22ce(%rip), %r12      # 0x9332
xorl %r13d, %r13d
cmpq %r14, %r13
je 0x70f4
movl (%rbx,%r13,4), %esi
movq 0x88(%r15), %rcx
movl 0x94(%r15), %edi
movslq %edi, %rdx
leaq 0x8(%rcx), %rax
testl %edi, %edi
jle 0x709a
cmpl -0x8(%rax), %esi
je 0x70a6
decl %edi
addq $0xc, %rax
jmp 0x7089
movq %r12, %rdi
xorl %eax, %eax
callq 0x3130
jmp 0x70ec
movl (%rax), %esi
testb $0x1, %sil
je 0x70e7
movl -0x4(%rax), %edi
andl $0x7f, %edi
je 0x70c7
shll $0x18, %edi
addl $0x1000000, %edi        # imm = 0x1000000
cmpl $0x2000000, %edi        # imm = 0x2000000
jl 0x70e7
addq $-0x8, %rax
imulq $0xc, %rdx, %rdx
movl -0x4(%rcx,%rdx), %esi
movl %esi, 0x8(%rax)
movq -0xc(%rcx,%rdx), %rcx
movq %rcx, (%rax)
decl 0x94(%r15)
jmp 0x70ec
orl $0x2, %esi
movl %esi, (%rax)
incq %r13
jmp 0x7067
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x257c(%rip), %rdi      # 0x5190
xorl %esi, %esi
xorl %eax, %eax
callq 0x2210
movl %eax, %ebp
callq 0x2290
testl %ebp, %ebp
js 0x2c6a
movslq %eax, %r14
imulq %r15, %r14
movq %rsp, %r15
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rcx
callq 0x2270
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2c51
incq (%rbx)
jmp 0x2c32
leaq 0x6aa(%rip), %rdi       # 0x3302
leaq 0x636(%rip), %rsi       # 0x3295
leaq 0x669(%rip), %rcx       # 0x32cf
pushq $0x28
jmp 0x2c81
leaq 0x61c(%rip), %rdi       # 0x328d
leaq 0x61d(%rip), %rsi       # 0x3295
leaq 0x650(%rip), %rcx       # 0x32cf
pushq $0x25
popq %rdx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %rbx
testq %rbx, %rbx
je 0x4fcd
movq (%rbx), %rax
testq %rax, %rax
je 0x4f62
movq 0x10(%rax), %rdi
movq 0x10(%rbx), %rsi
callq *%r14
testl %eax, %eax
js 0x4f66
xorl %eax, %eax
jmp 0x4f7c
movb $0x1, %al
jmp 0x4f7c
movq (%rbx), %rdi
callq 0x4e43
movq 0x10(%rax), %rdi
movq 0x10(%rbx), %rsi
callq *%r14
shrl $0x1f, %eax
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x4fb1
testb %al, %al
je 0x4fcd
movq 0x10(%rcx), %rdi
movq 0x10(%rbx), %rsi
callq *%r14
testl %eax, %eax
jle 0x4fcd
movq 0x8(%rbx), %rdi
callq 0x4e2d
movq 0x10(%rax), %rdi
movq 0x10(%rbx), %rsi
callq *%r14
testl %eax, %eax
setg %al
testb %al, %al
je 0x4fcd
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4f34
testb %al, %al
je 0x4fcd
movq 0x8(%rbx), %rbx
jmp 0x4f3e
testq %rbx, %rbx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4ff1
callq 0x4fdb
movq %rax, (%rbx)
jmp 0x4ff8
movq %rbx, (%rsi)
movq 0x8(%rbx), %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1570
pushq $0x8
popq %rax
cmpl $0x49, %ecx
je 0x1559
cmpl $0x6c, %ecx
jne 0x1588
movzbl 0x1(%rdi), %ecx
cmpl $0x31, %ecx
je 0x1594
cmpl $0x6c, %ecx
je 0x1591
cmpl $0x49, %ecx
jne 0x1588
pushq $0x1
jmp 0x1596
movzbl 0x1(%rdi), %ecx
cmpl $0x31, %ecx
je 0x158d
cmpl $0x6c, %ecx
je 0x1589
cmpl $0x49, %ecx
jne 0x1588
pushq $0x3
jmp 0x1596
movb 0x1(%rdi), %al
xorl %ecx, %ecx
cmpb $0x49, %al
setne %cl
leal (%rcx,%rcx,2), %ecx
addl $0x5, %ecx
cmpb $0x6c, %al
pushq $0x4
popq %rax
cmovnel %ecx, %eax
retq
pushq $0x2
jmp 0x1596
pushq $0x7
jmp 0x1596
xorl %eax, %eax
retq
pushq $0x6
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xcf9(%rip), %rdi       # 0x2004
leaq 0xcfd(%rip), %rsi       # 0x200f
callq 0x1202
testq %rax, %rax
je 0x1369
movq %rax, %rbx
pushq $0x1
popq %rbp
leaq 0x7(%rsp), %r14
pushq $0x1
popq %r15
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
testl %eax, %eax
jle 0x1346
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb (%rax), %al
jmp 0x134e
movq %rbx, %rdi
callq 0x118c
movb %al, 0x7(%rsp)
cmpb $-0x1, %al
je 0x1365
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1030
jmp 0x132b
xorl %ebx, %ebx
jmp 0x137d
leaq 0xca1(%rip), %rsi       # 0x2011
pushq $0x1
popq %rbx
pushq $0x21
popq %rdx
movl %ebx, %edi
callq 0x1030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2dae(%rip), %r15      # 0x3ff8
movq (%r15), %rcx
leaq 0xdb0(%rip), %rdi       # 0x2004
pushq $0x2d
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1120
movq (%r15), %rcx
leaq 0xdc6(%rip), %rdi       # 0x2032
pushq $0x2c
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1120
movq (%r15), %rcx
leaq 0xdda(%rip), %rdi       # 0x205f
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1120
movq (%r15), %rcx
leaq 0xdf2(%rip), %rdi       # 0x208c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1120
movq (%r15), %rcx
leaq 0xe0a(%rip), %rdi       # 0x20b9
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1120
movq (%r15), %rcx
leaq 0xe22(%rip), %rdi       # 0x20e6
pushq $0x24
popq %rsi
movq %rbx, %rdx
callq 0x1120
movq (%r15), %rcx
leaq 0xe32(%rip), %rdi       # 0x210b
pushq $0x1d
popq %rsi
movq %rbx, %rdx
callq 0x1120
movq (%r15), %rcx
leaq 0xe3b(%rip), %rdi       # 0x2129
pushq $0x40
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1120
movq (%r15), %rcx
leaq 0xe63(%rip), %rdi       # 0x216a
pushq $0xc
popq %rsi
movq %rbx, %rdx
callq 0x1120
movq (%r15), %rdi
leaq 0xe5b(%rip), %rsi       # 0x2177
pushq $0x1
popq %rbp
movl %ebp, %edx
movl $0x10000, %ecx          # imm = 0x10000
xorl %eax, %eax
callq 0x1090
movq (%r15), %rcx
leaq 0xe7d(%rip), %rdi       # 0x21b4
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1120
movq (%r15), %rcx
leaq 0xea9(%rip), %rdi       # 0x21f5
pushq $0x48
popq %rsi
movq %rbx, %rdx
callq 0x1120
movq (%r15), %rcx
leaq 0xedd(%rip), %rdi       # 0x223e
pushq $0x36
popq %rsi
movq %rbx, %rdx
callq 0x1120
movl %ebp, %edi
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/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 0xac9(%rip), %rsi       # 0x2285
callq 0x10f0
movq %rax, 0x12918(%rip)     # 0x140e0
testq %rax, %rax
je 0x17f0
callq 0x17f7
movl %eax, %ebx
movq 0x12905(%rip), %rdi     # 0x140e0
callq 0x1080
movl %ebx, %eax
decl %eax
cmpl $-0x3, %eax
ja 0x17f3
callq 0x1959
jmp 0x17f3
pushq $-0x3
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5864
orl $0x1, %eax
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x644a
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x58f0
movq %rbx, %rdi
callq 0x5160
movq %rax, %rbx
movq 0x1d75b(%rip), %rdi     # 0x22ff0
leaq 0x109a4(%rip), %rsi     # 0x16240
callq 0x5390
movq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x5390
leaq 0x10908(%rip), %rsi     # 0x161bd
movq %rax, %rdi
callq 0x5390
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x5390
leaq 0x10b6e(%rip), %rsi     # 0x16449
movq %rax, %rdi
callq 0x5390
callq 0x579c
movq %rax, %rbx
callq 0x5550
movq %rbx, %rdi
callq 0x55b0
movq %rax, %rdi
callq 0x6486
// File: /workspace/github_c_makefile_star2_O2/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, %r14
xorl %edi, %edi
callq 0x5280
movq %rax, %r15
leaq 0x1092f(%rip), %rdi     # 0x1624b
pushq $0x4
popq %rsi
callq 0x5530
subq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5940
callq 0x5180
notq %rax
addq %rax, %r15
addq $0x8, %r14
jmp 0x5927
subq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %r14
movq %rdi, %r15
movb $0x0, (%rax)
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x5070
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5bae
movq %r15, %rdi
movq %r12, %rsi
callq 0x6792
jmp 0x5b88
leaq 0x8(%rsp), %rdi
callq 0x51a0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x1, 0x20(%r14,%rax)
jne 0x5bd3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5050
movl (%rax), %edi
callq 0x5110
movq %rax, %r14
movq 0x1d407(%rip), %rdi     # 0x22ff0
leaq 0x1067a(%rip), %rsi     # 0x1626a
callq 0x5390
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5390
leaq 0x105b6(%rip), %rsi     # 0x161bd
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r14, %rsi
callq 0x5390
leaq 0x10828(%rip), %rsi     # 0x16449
movq %rax, %rdi
callq 0x5390
pushq $0x1
popq %rdi
callq 0x5460
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
movq %rsi, (%rsp)
cmpb $0x2d, (%rsi)
jne 0x5c66
movq %rsi, %rdx
cmpb $0x0, 0x1(%rsi)
je 0x5ce5
leaq 0x8(%rsp), %r14
movq %rsp, %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0x67e2
movq %r14, %rdi
callq 0x67d4
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x684e
testb %bpl, %bpl
jne 0x5cff
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5420
movq (%rsp), %rsi
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x5250
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x28(%rsp,%rax)
jne 0x5d35
movq (%rsp), %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5b5e
leaq 0x8(%rsp), %rdi
callq 0x50a0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
movq 0x1d2ec(%rip), %rsi     # 0x22fd8
movq %rbx, %rdi
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
jmp 0x5b5e
movq 0x1d2ea(%rip), %rdi     # 0x22ff0
leaq 0x10572(%rip), %rsi     # 0x1627f
callq 0x5390
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x5390
leaq 0x10724(%rip), %rsi     # 0x16449
movq %rax, %rdi
callq 0x5390
pushq $0x1
popq %rdi
callq 0x5460
callq 0x5050
movl (%rax), %edi
callq 0x5110
movq %rax, %rbx
movq 0x1d2a5(%rip), %rdi     # 0x22ff0
leaq 0x10544(%rip), %rsi     # 0x16296
callq 0x5390
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x5390
leaq 0x10453(%rip), %rsi     # 0x161bd
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5390
leaq 0x106c5(%rip), %rsi     # 0x16449
movq %rax, %rdi
callq 0x5390
jmp 0x5d2d
jmp 0x5d9f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x684e
jmp 0x5dac
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x50a0
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %r15
movq %rcx, %r14
cmpq %r15, %rcx
je 0x5de0
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6864
leaq 0x20(%r14), %rcx
testb %al, %al
je 0x5dc3
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
movq (%rsi), %rdi
callq 0x52e0
leaq 0x1049e(%rip), %rsi     # 0x162a6
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x688c
movq (%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x5630
movq 0x8(%rsp), %rdi
callq 0x57d6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movl %edi, %r14d
leaq 0xc(%rsp), %rsi
xorl %edx, %edx
callq 0x5310
cmpl $-0x1, %eax
je 0x5f07
movl %eax, %ebp
cmpl %r14d, %eax
jne 0x5f13
movl 0xc(%rsp), %ebp
movl %ebp, %r14d
andl $0x7f, %r14d
je 0x5ec3
movq 0x1d168(%rip), %rdi     # 0x22ff0
leaq 0x10469(%rip), %rsi     # 0x162f8
callq 0x5390
movq %rax, %rdi
movl %r14d, %esi
callq 0x5590
leaq 0x105a3(%rip), %rsi     # 0x16449
movq %rax, %rdi
callq 0x5390
testb %bl, %bl
je 0x5efe
callq 0x5510
movl %eax, %edi
movl %r14d, %esi
callq 0x54f0
jmp 0x5f3f
shrl $0x8, %ebp
andl $0xff, %ebp
je 0x5efe
movq 0x1d11b(%rip), %rdi     # 0x22ff0
leaq 0x10407(%rip), %rsi     # 0x162e3
callq 0x5390
movq %rax, %rdi
movl %ebp, %esi
callq 0x5590
leaq 0x10557(%rip), %rsi     # 0x16449
movq %rax, %rdi
callq 0x5390
testb %bl, %bl
jne 0x5f47
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x103a4(%rip), %rdi     # 0x162b2
callq 0x57d6
movq 0x1d0d6(%rip), %rdi     # 0x22ff0
leaq 0x10399(%rip), %rsi     # 0x162ba
callq 0x5390
movq %rax, %rdi
movl %ebp, %esi
callq 0x5590
leaq 0x10398(%rip), %rsi     # 0x162cf
movq %rax, %rdi
callq 0x5390
pushq $0x1
popq %rdi
callq 0x5460
movl %ebp, %edi
callq 0x5460
// File: /workspace/github_c_makefile_star2_O2/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 0x5db4
testb %al, %al
je 0x5f69
xorl %eax, %eax
jmp 0x5f8b
movq 0x70(%rbx), %rax
cmpq 0x68(%rbx), %rax
je 0x5f89
addq $0x68, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5db4
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %eax, %eax
cmpq $0x7, %rax
je 0x172e
andq $0x0, (%rbx,%rax,8)
incq %rax
jmp 0x171e
xorl %r12d, %r12d
leaq 0x4(%rsp), %r13
pushq $-0x1
popq %rbp
cmpq $0x4, %r12
je 0x175c
movl (%r14,%r12,4), %esi
movq %rbx, %rdi
movq %rsp, %rdx
movq %r13, %rcx
movl %ebp, %r8d
movl %ebp, %r9d
callq 0x10b0
incq %r12
jmp 0x1739
xorl %r12d, %r12d
leaq 0x4(%rsp), %r13
pushq $-0x1
popq %rbp
cmpq $0x4, %r12
je 0x178a
movl (%r15,%r12,4), %esi
movq %rbx, %rdi
movq %rsp, %rdx
movq %r13, %rcx
movl %ebp, %r8d
movl %ebp, %r9d
callq 0x10b0
incq %r12
jmp 0x1767
movl (%r14), %esi
xorl $0x1, %esi
movq %rsp, %r15
leaq 0x4(%rsp), %r12
pushq $-0x1
popq %rbp
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
movl %ebp, %r8d
movl %ebp, %r9d
callq 0x10b0
pushq $0x9
popq %r13
cmpl $0x38, %r13d
je 0x17dc
movl %r13d, %eax
andl $0x3, %eax
movl (%r14,%rax,4), %esi
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
movl %ebp, %r8d
movl %ebp, %r9d
callq 0x10b0
incl %r13d
jmp 0x17b3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsp, %r15
andl $0x0, (%r15)
xorl %r13d, %r13d
leaq 0x4(%rsp), %r12
pushq $-0x1
popq %rbp
cmpq $0x18, %r13
je 0x183d
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movl %ebp, %r8d
movl %ebp, %r9d
callq 0x10b0
cmpq $0x14, %r13
jb 0x1838
movl (%rsp), %eax
movl %eax, -0x50(%r14,%r13,4)
incq %r13
jmp 0x180e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2534
movq (%rdi), %rcx
movabsq $-0x7ffd000000000002, %rax # imm = 0x8002FFFFFFFFFFFE
addq %rcx, %rax
cmpq $0x2, %rax
jae 0x24ed
pushq $0x1
popq %rax
jmp 0x252e
xorl %eax, %eax
movabsq $0x7ffc000000000000, %rdx # imm = 0x7FFC000000000000
cmpq %rdx, %rcx
je 0x252e
movq %rcx, %rax
notq %rax
testq %rdx, %rax
jne 0x2530
movq %rcx, %rax
shrq $0x32, %rax
cmpl $0x3ffe, %eax           # imm = 0x3FFE
jbe 0x2567
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %rcx
movl (%rcx), %eax
cmpl $0x9, %eax
jae 0x2591
addl $0x3, %eax
popq %rcx
retq
pushq $0x2
jmp 0x24ea
movq 0x20abd(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x15bab(%rip), %rsi     # 0x180f0
leaq 0x15bcb(%rip), %rdx     # 0x18117
leaq 0x15bda(%rip), %rcx     # 0x1812d
leaq 0x15be2(%rip), %r8      # 0x1813c
pushq $0x13
popq %r9
xorl %eax, %eax
callq 0x2250
ud2
movq 0x20a8a(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x15b78(%rip), %rsi     # 0x180f0
leaq 0x15bca(%rip), %rdx     # 0x18149
leaq 0x15ba7(%rip), %rcx     # 0x1812d
leaq 0x15baf(%rip), %r8      # 0x1813c
pushq $0x1a
jmp 0x255c
movq 0x20a60(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x15bd8(%rip), %rsi     # 0x1817a
leaq 0x15b84(%rip), %rdx     # 0x1812d
leaq 0x15b8c(%rip), %rcx     # 0x1813c
pushq $0x29
popq %r8
xorl %eax, %eax
callq 0x2250
ud2
// File: /workspace/github_c_makefile_star2_O2/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 0x25d9
movq %r14, %rdi
callq 0x2140
movq %rax, %rdx
jmp 0x25db
xorl %edx, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x261f
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5cb0
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %r14, %rsi
movq %rbx, %rdi
callq 0x5aa3
movq %rax, %r14
movq %rbx, %rdi
callq 0x5dac
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %edx, %edx
sete %al
testq %rsi, %rsi
setne %cl
orb %al, %cl
je 0x2685
movl %edx, %ebp
movq %rsi, %rbx
testq %rsi, %rsi
sete %r12b
movl %edx, %r15d
movq %r15, %rsi
callq 0x34d8
movq %rax, %r14
testl %ebp, %ebp
sete %al
orb %r12b, %al
jne 0x2669
leaq 0x1c(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2280
movq %r14, %rdi
addq $0x1c, %rdi
callq 0xabd7
movl %eax, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2096c(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x15a5a(%rip), %rsi     # 0x180f0
leaq 0x15b3f(%rip), %rdx     # 0x181dc
leaq 0x15b50(%rip), %rcx     # 0x181f4
leaq 0x15a91(%rip), %r8      # 0x1813c
movl $0x14a, %r9d            # imm = 0x14A
xorl %eax, %eax
callq 0x2250
ud2
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x261f
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5cb0
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %r14, %rsi
movq %rbx, %rdi
callq 0x5aa3
movq %rax, %r14
movq %rbx, %rdi
callq 0x5dac
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x2747
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5cb0
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %r14, %rsi
movq %rbx, %rdi
callq 0x5aa3
movq %rax, %r14
movq %rbx, %rdi
callq 0x5dac
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x20
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x5a41
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5cb0
movl $0x1, (%r14)
movb $0x0, 0x4(%r14)
movq (%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
testl %ebp, %ebp
je 0x27ac
movq %r14, %rdi
addq $0x10, %rdi
movabsq $0x7ffc000000000000, %rdx # imm = 0x7FFC000000000000
movq %rbx, %rsi
movl %ebp, %ecx
callq 0x2cf0
andl $0x0, 0x18(%r14)
movq %rbx, %rdi
callq 0x5dac
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2801
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5cb0
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %r14, %rsi
movq %rbx, %rdi
callq 0x5aa3
movq %rax, %r14
movq %rbx, %rdi
callq 0x5dac
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
pushq $0x20
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x5a41
movl $0x2, (%rax)
movb $0x0, 0x4(%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %rsi
movq %rsi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x289b
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %rsi
cmpl $0x5, (%rsi)
jne 0x289b
movq %rdi, %rbx
movabsq $-0x4000000000001, %r14 # imm = 0xFFFBFFFFFFFFFFFF
callq 0x28ce
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5cb0
incq %r14
orq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5aa3
movq %rax, %r14
movq %rbx, %rdi
callq 0x5dac
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x20756(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x15844(%rip), %rsi     # 0x180f0
leaq 0x158ff(%rip), %rdx     # 0x181b2
leaq 0x15917(%rip), %rcx     # 0x181d1
leaq 0x1587b(%rip), %r8      # 0x1813c
pushq $0x4d
popq %r9
xorl %eax, %eax
callq 0x2250
ud2
// File: /workspace/github_c_makefile_star2_O2/atomlang[P]atomlang/src/pk_var.c
// Function: newFiber
Fiber* newFiber(PKVM* vm, Function* fn) {
  Fiber* fiber = ALLOCATE(vm, Fiber);
  memset(fiber, 0, sizeof(Fiber));
  varInitObject(&fiber->_super, vm, OBJ_FIBER);

  fiber->state = FIBER_NEW;
  fiber->func = fn;

  if (fn->is_native) {
    // For native functions, we're only using stack for parameters,
    // there won't be any locals or temps (which are belongs to the
    // native "C" stack).
    int stack_size = utilPowerOf2Ceil(fn->arity + 1);
    fiber->stack = ALLOCATE_ARRAY(vm, Var, stack_size);
    fiber->stack_size = stack_size;
    fiber->ret = fiber->stack;
    fiber->sp = fiber->stack + 1;

  } else {
    // Allocate stack.
    int stack_size = utilPowerOf2Ceil(fn->fn->stack_size + 1);
    if (stack_size < MIN_STACK_SIZE) stack_size = MIN_STACK_SIZE;
    fiber->stack = ALLOCATE_ARRAY(vm, Var, stack_size);
    fiber->stack_size = stack_size;
    fiber->ret = fiber->stack;
    fiber->sp = fiber->stack + 1;

    // Allocate call frames.
    fiber->frame_capacity = INITIAL_CALL_FRAMES;
    fiber->frames = ALLOCATE_ARRAY(vm, CallFrame, fiber->frame_capacity);
    fiber->frame_count = 1;

    // Initialize the first frame.
    fiber->frames[0].fn = fn;
    fiber->frames[0].ip = fn->fn->opcodes.data;
    fiber->frames[0].rbp = fiber->ret;
  }

  // Initialize the return value to null (doesn't really have to do that here
  // but if we're trying to debut it may crash when dumping the return value).
  *fiber->ret = VAR_NULL;

  return fiber;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
pushq $0x60
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x5a41
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movl $0x6, (%rax)
movq (%r14), %rax
movq %rax, 0x8(%rbx)
movq %rbx, (%r14)
movq %r15, 0x18(%rbx)
cmpb $0x1, 0x30(%r15)
jne 0x295b
movl 0x20(%r15), %edi
incl %edi
callq 0xab40
movslq %eax, %r15
leaq (,%r15,8), %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5a41
movq %rax, 0x20(%rbx)
movl %r15d, 0x28(%rbx)
movq %rax, 0x38(%rbx)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x30(%rbx)
jmp 0x29da
movq 0x38(%r15), %rax
movl 0x20(%rax), %edi
incl %edi
callq 0xab40
cmpl $0x81, %eax
movl $0x80, %r12d
cmovgel %eax, %r12d
leaq (,%r12,8), %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5a41
movq %rax, 0x20(%rbx)
movl %r12d, 0x28(%rbx)
movq %rax, 0x38(%rbx)
addq $0x8, %rax
movq %rax, 0x30(%rbx)
movl $0x4, 0x48(%rbx)
pushq $0x60
popq %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5a41
movq %rax, %rcx
movq %rax, 0x40(%rbx)
movl $0x1, 0x4c(%rbx)
movq %r15, 0x8(%rax)
movq 0x38(%r15), %rax
movq (%rax), %rax
movq %rax, (%rcx)
movq 0x38(%rbx), %rax
movq %rax, 0x10(%rcx)
movabsq $0x7ffc000000000000, %rcx # imm = 0x7FFC000000000000
movq %rcx, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2a3b
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5cb0
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
orq %r14, %rsi
movq %rbx, %rdi
callq 0x5aa3
movq %rax, %r14
movq %rbx, %rdi
callq 0x5dac
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x28
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x5a41
movq %rax, %r14
movl $0x8, (%rax)
movb $0x0, 0x4(%rax)
movq (%r15), %rax
movq %rax, 0x8(%r14)
movq %r14, (%r15)
movb $0x1, 0x18(%r14)
movl %ebp, 0x1c(%r14)
movq 0xf0(%r15), %rax
testq %rax, %rax
je 0x2a88
movl %ebp, %edi
callq *%rax
jmp 0x2a8f
leaq 0x157c6(%rip), %rax     # 0x18255
movq %rax, 0x10(%r14)
movq %rbx, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x21(%rsi), %rcx
xorl %r15d, %r15d
xorl %esi, %esi
xorl %edx, %edx
callq 0x5a41
andl $0x0, (%rax)
movb %r15b, 0x4(%rax)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r14)
movl %ebx, 0x14(%rax)
movb %r15b, 0x1c(%rax,%rbx)
leal 0x1(%rbx), %ecx
movl %ecx, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/atomlang[P]atomlang/src/pk_var.c
// Function: newRange
Range* newRange(PKVM* vm, double from, double to) {
  Range* range = ALLOCATE(vm, Range);
  varInitObject(&range->_super, vm, OBJ_RANGE);
  range->from = from;
  range->to = to;
  return range;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
pushq $0x20
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x5a41
movl $0x3, (%rax)
movb $0x0, 0x4(%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/atomlang[P]atomlang/src/pk_var.c
// Function: newScript
Script* newScript(PKVM* vm, String* name, bool is_core) {
  Script* script = ALLOCATE(vm, Script);
  varInitObject(&script->_super, vm, OBJ_SCRIPT);

  ASSERT(name != NULL && name->length > 0, OOPS);

  script->path = name;
  script->module = NULL;
  script->initialized = is_core;
  script->body = NULL;

  // Core modules has its name as the module name.
  if (is_core) script->module = name;

  pkVarBufferInit(&script->globals);
  pkUintBufferInit(&script->global_names);
  pkVarBufferInit(&script->literals);
  pkFunctionBufferInit(&script->functions);
  pkClassBufferInit(&script->classes);
  pkStringBufferInit(&script->names);

  // Add a implicit main function and the '__file__' global to the module, only
  // if it's not a core module.
  if (!is_core) {
    vmPushTempRef(vm, &script->_super);
    scriptAddMain(vm, script);

    // Add '__file__' variable with it's path as value. If the path starts with
    // '$' It's a special file ($(REPL) or $(TRY)) and don't define __file__.
    if (script->path->data[0] != '$') {
      scriptAddGlobal(vm, script, "__file__", 8, VAR_OBJ(script->path));
    }

    // TODO: Add ARGV as a global.

    vmPopTempRef(vm); // script.
  }

  return script;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movl $0x90, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x5a41
movq %rax, %rbx
movl $0x4, (%rax)
movb $0x0, 0x4(%rax)
movq (%r14), %rax
movq %rax, 0x8(%rbx)
movq %rbx, (%r14)
testq %r15, %r15
je 0x3660
cmpl $0x0, 0x14(%r15)
je 0x3660
movq %r15, 0x18(%rbx)
andq $0x0, 0x10(%rbx)
movb %bpl, 0x88(%rbx)
andq $0x0, 0x80(%rbx)
testb %bpl, %bpl
je 0x35ec
movq %r15, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
jmp 0x3652
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5cb0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3695
movq 0x18(%rbx), %r8
cmpb $0x24, 0x1c(%r8)
je 0x364a
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %r8
leaq 0x14bee(%rip), %rdx     # 0x1822a
pushq $0x8
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3704
movq %r14, %rdi
callq 0x5dac
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x1f991(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x14a7f(%rip), %rsi     # 0x180f0
leaq 0x14b8c(%rip), %rdx     # 0x18204
leaq 0x14ba1(%rip), %rcx     # 0x18220
leaq 0x14ab6(%rip), %r8      # 0x1813c
movl $0x176, %r9d            # imm = 0x176
xorl %eax, %eax
callq 0x2250
ud2
// File: /workspace/github_c_makefile_star2_O2/atomlang[P]atomlang/src/pk_var.c
// Function: scriptAddMain
void scriptAddMain(PKVM* vm, Script* script) {
  ASSERT(script->body == NULL, OOPS);

  const char* fn_name = PK_IMPLICIT_MAIN_NAME;
  script->body = newFunction(vm, fn_name, (int)strlen(fn_name),
                             script, false, NULL/*TODO*/);
  script->body->arity = 0;
  script->initialized = false;
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x80(%rsi)
jne 0x36cf
movq %rsi, %rbx
leaq 0x14bdd(%rip), %rsi     # 0x18287
pushq $0xd
popq %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x37b0
movq %rax, 0x80(%rbx)
andl $0x0, 0x20(%rax)
movb $0x0, 0x88(%rbx)
popq %rbx
retq
movq 0x1f922(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x14a10(%rip), %rsi     # 0x180f0
leaq 0x14b1d(%rip), %rdx     # 0x18204
leaq 0x14b8b(%rip), %rcx     # 0x18279
leaq 0x14a47(%rip), %r8      # 0x1813c
movl $0x484, %r9d            # imm = 0x484
xorl %eax, %eax
callq 0x2250
ud2
// File: /workspace/github_c_makefile_star2_O2/atomlang[P]atomlang/src/pk_var.c
// Function: scriptAddGlobal
uint32_t scriptAddGlobal(PKVM* vm, Script* script,
                    const char* name, uint32_t length,
                    Var value) {

  // If already exists update the value.
  int var_ind = scriptGetGlobals(script, name, length);
  if (var_ind != -1) {
    ASSERT(var_ind < (int)script->globals.count, OOPS);
    script->globals.data[var_ind] = value;
    return var_ind;
  }

  // If we're reached here that means we don't already have a variable with
  // that name, create new one and set the value.
  uint32_t name_ind = scriptAddName(script, vm, name, length);
  pkUintBufferWrite(&script->global_names, vm, name_ind);
  pkVarBufferWrite(&script->globals, vm, value);
  return script->globals.count - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
callq 0x4936
cmpl $-0x1, %eax
je 0x373f
cmpl 0x28(%r14), %eax
jge 0x377b
movq 0x20(%r14), %rcx
movslq %eax, %rdx
movq %rbx, (%rcx,%rdx,8)
jmp 0x3772
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x38d9
leaq 0x30(%r14), %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x2b54
leaq 0x20(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2d2b
movl 0x28(%r14), %eax
decl %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x1f876(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x14964(%rip), %rsi     # 0x180f0
leaq 0x14a71(%rip), %rdx     # 0x18204
leaq 0x14acf(%rip), %rcx     # 0x18269
leaq 0x1499b(%rip), %r8      # 0x1813c
movl $0x476, %r9d            # imm = 0x476
xorl %eax, %eax
callq 0x2250
ud2