LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: jd_strdup
char *jd_strdup(const char *src)
{
	char *dst;

	dst = strdup(src);
	if (!dst)
		err_handler(errno, "strdup()");

	return dst;
}

// Assembly:
pushq %rax
callq 0x2250
testq %rax, %rax
je 0x2bfd
popq %rcx
retq
callq 0x2050
movl (%rax), %edi
leaq 0x1465(%rip), %rsi      # 0x4070
leaq 0x1446(%rip), %rdx      # 0x4058
leaq 0x1469(%rip), %rcx      # 0x4082
xorl %eax, %eax
callq 0x25f8
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: jd_fopen
FILE *jd_fopen(const char *path, const char *filename, const char *mode)
{
	FILE *fd;
	char *fn, *tmp;

	tmp = jd_strdup(filename);
	if (asprintf(&fn, "%s/%s", path, basename(tmp)) < 0)
		err_handler(errno, "asprintf()");

	fd = fopen(fn, mode);

	free(tmp);
	free(fn);

	return fd;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2bf0
movq %rax, %r14
movq %rax, %rdi
callq 0x2170
leaq 0x1443(%rip), %rsi      # 0x408c
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x21b0
testl %eax, %eax
js 0x2c8e
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x21e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2030
movq 0x8(%rsp), %rdi
callq 0x2030
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x2050
movl (%rax), %edi
leaq 0x13f6(%rip), %rsi      # 0x4092
leaq 0x13b5(%rip), %rdx      # 0x4058
leaq 0x13fc(%rip), %rcx      # 0x40a6
xorl %eax, %eax
callq 0x25f8
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: jd_cp
void jd_cp(const char *src, const char *path)
{
	char buf[BUFSIZ];
	FILE *fds, *fdd;
	size_t n;

	fds = fopen(src, "r");
	if (!fds) {
		warn_handler("Could not open '%s' for reading", src);
		return;
	}

	fdd = jd_fopen(path, src, "w");
	if (!fdd) {
		fclose(fdd);
		warn_handler("Could not copy '%s'", src);
		return;
	}

	while ((n = fread(buf, sizeof(char), sizeof(buf), fds)) > 0) {
		if (fwrite(buf, sizeof(char), n, fdd) != n) {
			warn_handler("Could not copy '%s'", src);
			goto out;
		}
	}
out:
	fclose(fdd);
	fclose(fds);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x13e1(%rip), %rsi      # 0x40af
callq 0x21e0
testq %rax, %rax
je 0x2d74
movq %rax, %r14
leaq 0x15cb(%rip), %rdx      # 0x42b1
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2c20
testq %rax, %rax
je 0x2d7d
movq %rax, %r15
movq %rsp, %r12
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %r12, %rdi
movq %r14, %rcx
callq 0x20a0
testq %rax, %rax
je 0x2d54
movq %rax, %r13
movl $0x1, %esi
movq %r12, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0x2230
cmpq %r13, %rax
je 0x2d00
leaq 0x13a5(%rip), %rdi      # 0x40e1
leaq 0x1315(%rip), %rsi      # 0x4058
leaq 0x1391(%rip), %rdx      # 0x40db
movq %rbx, %rcx
xorl %eax, %eax
callq 0x26c7
movq %r15, %rdi
callq 0x20c0
movq %r14, %rdi
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x20c0
leaq 0x1336(%rip), %rdi      # 0x40b1
jmp 0x2d8b
xorl %edi, %edi
callq 0x20c0
leaq 0x1356(%rip), %rdi      # 0x40e1
leaq 0x12c6(%rip), %rsi      # 0x4058
leaq 0x1342(%rip), %rdx      # 0x40db
movq %rbx, %rcx
xorl %eax, %eax
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x26c7
nop
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_samples_csv.c
// Function: output_csv
static int output_csv(struct jd_samples_info *info, FILE *input)
{
	struct latency_sample sample;
	FILE *output;

	output = jd_fopen(info->dir, "samples.csv", "w");
	if (!output)
		err_handler(errno, "Could not open '%s/samples.csv' for writing",
			info->dir);

	while(fread(&sample, sizeof(struct latency_sample), 1, input)) {
		fprintf(output, "%d;%lld.%.9ld;%" PRIu64 "\n",
			sample.cpuid,
			(long long)sample.ts.tv_sec,
			sample.ts.tv_nsec,
			sample.val);
	}

	fclose(output);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
leaq 0x1379(%rip), %rsi      # 0x4148
leaq 0x14db(%rip), %rdx      # 0x42b1
callq 0x2c20
movq %rax, %r14
testq %rax, %rax
jne 0x2e09
callq 0x2050
movl (%rax), %edi
movq (%r15), %r8
leaq 0x1360(%rip), %rsi      # 0x4154
leaq 0x138e(%rip), %rdx      # 0x4189
leaq 0x1398(%rip), %rcx      # 0x419a
xorl %eax, %eax
callq 0x25f8
leaq 0xc(%rsp), %rdi
movl $0x1c, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x20a0
testq %rax, %rax
je 0x2e6b
leaq 0x1379(%rip), %r15      # 0x41a5
leaq 0xc(%rsp), %r12
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2160
movl $0x1c, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x20a0
testq %rax, %rax
jne 0x2e31
movq %r14, %rdi
callq 0x20c0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_plugin.c
// Function: jd_slist_append
void jd_slist_append(struct jd_slist *jd_slist, void *data)
{
	struct jd_slist *l;

	for (l = jd_slist; l && l->next; l = l->next)
		/* do nothing */ ;

	if (!l)
		err_abort("linked list is inconsistent");

	l->next = malloc(sizeof(struct jd_slist));
	if (!l->next)
		err_abort("allocation for link list failed");
	bzero(l->next, sizeof(*l->next));

	l->next->data = data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x2edc
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x2ea3
movl $0x10, %edi
callq 0x2190
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x2ee1
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x8(%r14), %rax
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22e9
callq 0x22c4
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_plugin.c
// Function: _jd_plugin_init
void __jd_plugin_init(void)
{
	int i;

	for (i = 0; __jd_builtin[i]; i++) {
		struct jd_plugin_desc *desc = __jd_builtin[i];

		if (desc->init()) {
			err_abort("plugin initialization failed: %s",
				desc->name);
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x3274(%rip), %r14      # 0x6190
movq (%r14), %rbx
testq %rbx, %rbx
je 0x2f3b
addq $0x8, %r14
callq *0x8(%rbx)
testl %eax, %eax
jne 0x2f43
movq (%r14), %rbx
addq $0x8, %r14
testq %rbx, %rbx
jne 0x2f28
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x230e
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jittersamples.c
// Function: usage
static void __attribute__((noreturn)) usage(int status)
{
	printf("jittersamples [options] [DIR]\n");
	printf("  DIR			Directory generated by jitterdebugger --output\n");
	printf("\n");
	printf("Usage:\n");
	printf("  -h, --help		Print this help\n");
	printf("      --version		Print version of jittersamples\n");
	printf("  -f, --format FMT	Exporting samples in format [csv, hdf5]\n");
	printf("  -l, --listen PORT	Listen on PORT, dump samples to stdout\n");

	exit(status);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leaq 0x1250(%rip), %rdi      # 0x4473
callq 0x2080
leaq 0x1262(%rip), %rdi      # 0x4491
callq 0x2080
movl $0xa, %edi
callq 0x2040
leaq 0x1283(%rip), %rdi      # 0x44c8
callq 0x2080
leaq 0x127e(%rip), %rdi      # 0x44cf
callq 0x2080
leaq 0x1290(%rip), %rdi      # 0x44ed
callq 0x2080
leaq 0x12b4(%rip), %rdi      # 0x451d
callq 0x2080
leaq 0x12e3(%rip), %rdi      # 0x4558
callq 0x2080
movl %ebx, %edi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jittersamples.c
// Function: dump_samples
static void dump_samples(const char *port)
{
	struct addrinfo hints, *res, *tmp;
	struct latency_sample sp[SAMPLES_PER_PACKET];
	ssize_t len;
	size_t wlen;
	int err, sk;

	bzero(&hints, sizeof(struct addrinfo));
	hints.ai_flags = AI_PASSIVE;
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_DGRAM;
	hints.ai_protocol = IPPROTO_UDP;

	err = getaddrinfo(NULL, port, &hints, &res);
	if (err < 0)
		err_handler(errno, "getaddrinfo()");

	tmp = res;
	do {
		sk = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
		if (sk < 0)
			continue;
		err = bind(sk, res->ai_addr, res->ai_addrlen);
		if (err == 0)
			break;

		close(sk);
		res = res->ai_next;
	} while(res);

	freeaddrinfo(tmp);

	while (1) {
		len = recvfrom(sk, sp, sizeof(sp), 0, NULL, NULL);
		if (len != sizeof(sp)) {
			warn_handler("UDP packet has wrong size\n");
			continue;
		}
		wlen = fwrite(sp, sizeof(sp), 1, stdout);
		if (wlen != sizeof(sp))
			err_handler(errno, "fwrite()");
	}

	close(sk);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5b8, %rsp            # imm = 0x5B8
movq %rdi, %rsi
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movaps 0xfb4(%rip), %xmm0      # 0x4260
movaps %xmm0, (%rdx)
leaq 0x8(%rsp), %rcx
xorl %edi, %edi
callq 0x2240
testl %eax, %eax
jns 0x32e2
callq 0x2050
movl (%rax), %edi
leaq 0x105c(%rip), %rsi      # 0x4329
leaq 0x1014(%rip), %rdx      # 0x42e8
leaq 0x1065(%rip), %rcx      # 0x4340
xorl %eax, %eax
callq 0x25f8
movq 0x8(%rsp), %r14
movq 0x8(%rsp), %rax
movl 0x4(%rax), %edi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2280
movl %eax, %ebx
testl %eax, %eax
js 0x332c
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movl 0x10(%rax), %edx
movl %ebx, %edi
callq 0x21c0
testl %eax, %eax
je 0x3334
movl %ebx, %edi
callq 0x2110
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x32e7
movq %r14, %rdi
callq 0x2270
leaq 0x40(%rsp), %r14
movq 0x2c80(%rip), %r15      # 0x5fc8
leaq 0xf99(%rip), %r12       # 0x42e8
leaq 0xfea(%rip), %r13       # 0x4340
leaq 0xff0(%rip), %rbp       # 0x434d
movl $0x578, %edx            # imm = 0x578
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x21a0
cmpq $0x578, %rax            # imm = 0x578
jne 0x33b6
movq (%r15), %rcx
movl $0x578, %esi            # imm = 0x578
movl $0x1, %edx
movq %r14, %rdi
callq 0x2230
cmpq $0x578, %rax            # imm = 0x578
je 0x335d
callq 0x2050
movl (%rax), %edi
leaq 0xfcb(%rip), %rsi       # 0x4372
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x25f8
jmp 0x335d
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x26c7
jmp 0x335d
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/combinators.c
// Function: test_check
void test_check(void) {
  int success;
  mpc_result_t  r;
  mpc_parser_t* p = mpc_check(mpc_or(2, mpc_char('a'), mpc_char('b')), free, check_is_a, "Expected 'a'");

  success = mpc_parse("test", "a", p, &r);
  PT_ASSERT(success);
  PT_ASSERT_STR_EQ(r.output, "a");
  if (success) free(r.output); else mpc_err_delete(r.error);

  success = mpc_parse("test", "b", p, &r);
  PT_ASSERT(!success);
  PT_ASSERT_STR_EQ(r.error->failure, "Expected 'a'");
  if (success) free(r.output); else mpc_err_delete(r.error);

  mpc_delete(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0x61, %edi
callq 0x79a1
movq %rax, %rbx
movl $0x62, %edi
callq 0x79a1
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x807e
movq 0x16c20(%rip), %rsi     # 0x17fc8
leaq 0x126(%rip), %rdx       # 0x14d5
leaq 0xdc4e(%rip), %rcx      # 0xf004
movq %rax, %rdi
callq 0x7bea
movq %rax, %rbx
leaq 0xdc49(%rip), %rdi      # 0xf011
leaq 0x110ad(%rip), %r15     # 0x1247c
leaq 0x8(%rsp), %r14
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x6ba1
movl %eax, %ebp
leaq 0xdc5d(%rip), %rsi      # 0xf048
leaq 0xdc24(%rip), %r12      # 0xf016
movl %eax, %edi
movq %r12, %rdx
movl $0x12, %ecx
callq 0x4050
movq (%r14), %rdi
movq %r15, %rsi
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xdc0f(%rip), %rsi      # 0xf02a
movq %r12, %rdx
movl $0x13, %ecx
callq 0x4050
movq (%r14), %rdi
testl %ebp, %ebp
je 0x1436
callq 0x1270
jmp 0x143b
callq 0x566c
leaq 0xdbcf(%rip), %rdi      # 0xf011
leaq 0x10069(%rip), %rsi     # 0x114b2
leaq 0x8(%rsp), %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6ba1
movl %eax, %ebp
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xdbdd(%rip), %rsi      # 0xf047
leaq 0xdba5(%rip), %r15      # 0xf016
movq %r15, %rdx
movl $0x17, %ecx
callq 0x4050
movq (%r14), %rax
movq 0x30(%rax), %rdi
leaq 0xdb78(%rip), %rsi      # 0xf004
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xdbb0(%rip), %rsi      # 0xf050
movq %r15, %rdx
movl $0x18, %ecx
callq 0x4050
movq (%r14), %rdi
testl %ebp, %ebp
je 0x14bb
callq 0x1270
jmp 0x14c0
callq 0x566c
movq %rbx, %rdi
callq 0x7052
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/combinators.c
// Function: test_check_with
void test_check_with(void) {
  int success;
  mpc_result_t  r;
  mpc_parser_t* p = mpc_check_with(mpc_or(2, mpc_char('a'), mpc_char('b')), free, check_is, (void*)"a", "Expected 'a'");

  success = mpc_parse("test", "a", p, &r);
  PT_ASSERT(success);
  if (success) PT_ASSERT_STR_EQ(r.output, "a");
  if (success) free(r.output); else mpc_err_delete(r.error);

  success = mpc_parse("test", "b", p, &r);
  PT_ASSERT(!success);
  if (!success) PT_ASSERT_STR_EQ(r.error->failure, "Expected 'a'");
  if (success) free(r.output); else mpc_err_delete(r.error);

  mpc_delete(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x61, %edi
callq 0x79a1
movq %rax, %rbx
movl $0x62, %edi
callq 0x79a1
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x807e
movq 0x16aa1(%rip), %rsi     # 0x17fc8
leaq 0x12b(%rip), %rdx       # 0x1659
leaq 0x10f47(%rip), %r14     # 0x1247c
leaq 0xdac8(%rip), %r8       # 0xf004
movq %rax, %rdi
movq %r14, %rcx
callq 0x7c57
movq %rax, %rbx
leaq 0xdac0(%rip), %rdi      # 0xf011
movq %rsp, %r15
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x6ba1
movl %eax, %ebp
leaq 0xdadd(%rip), %rsi      # 0xf048
leaq 0xdaa4(%rip), %rdx      # 0xf016
movl %eax, %edi
movl $0x24, %ecx
callq 0x4050
movq (%r15), %rdi
testl %ebp, %ebp
je 0x15bc
leaq 0x10ef0(%rip), %rsi     # 0x1247c
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xda8a(%rip), %rsi      # 0xf02a
leaq 0xda6f(%rip), %rdx      # 0xf016
movl $0x25, %ecx
callq 0x4050
movq (%rsp), %rdi
callq 0x1270
jmp 0x15c1
callq 0x566c
leaq 0xda49(%rip), %rdi      # 0xf011
leaq 0xfee3(%rip), %rsi      # 0x114b2
movq %rsp, %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6ba1
movl %eax, %ebp
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xda59(%rip), %rsi      # 0xf047
leaq 0xda21(%rip), %rdx      # 0xf016
movl $0x29, %ecx
callq 0x4050
movq (%r14), %rdi
testl %ebp, %ebp
je 0x160d
callq 0x1270
jmp 0x1646
movq 0x30(%rdi), %rdi
leaq 0xd9ec(%rip), %rsi      # 0xf004
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xda24(%rip), %rsi      # 0xf050
leaq 0xd9e3(%rip), %rdx      # 0xf016
movl $0x2a, %ecx
callq 0x4050
movq (%rsp), %rdi
callq 0x566c
movq %rbx, %rdi
callq 0x7052
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/combinators.c
// Function: test_checkf
void test_checkf(void) {
  int success;
  mpc_result_t  r;
  mpc_parser_t* p = mpc_checkf(mpc_or(2, mpc_char('a'), mpc_char('b')), free, check_is_a, "Expected '%s'", "a");

  success = mpc_parse("test", "a", p, &r);
  PT_ASSERT(success);
  PT_ASSERT_STR_EQ(r.output, "a");
  if (success) free(r.output); else mpc_err_delete(r.error);

  success = mpc_parse("test", "b", p, &r);
  PT_ASSERT(!success);
  PT_ASSERT_STR_EQ(r.error->failure, "Expected 'a'");
  if (success) free(r.output); else mpc_err_delete(r.error);

  mpc_delete(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0x61, %edi
callq 0x79a1
movq %rax, %rbx
movl $0x62, %edi
callq 0x79a1
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x807e
movq 0x1691f(%rip), %rsi     # 0x17fc8
leaq -0x1db(%rip), %rdx      # 0x14d5
leaq 0xd9c9(%rip), %rcx      # 0xf080
leaq 0x10dbe(%rip), %r15     # 0x1247c
movq %rax, %rdi
movq %r15, %r8
xorl %eax, %eax
callq 0x7cd2
movq %rax, %rbx
leaq 0xd93c(%rip), %rdi      # 0xf011
leaq 0x8(%rsp), %r14
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x6ba1
movl %eax, %ebp
leaq 0xd957(%rip), %rsi      # 0xf048
leaq 0xd91e(%rip), %r12      # 0xf016
movl %eax, %edi
movq %r12, %rdx
movl $0x36, %ecx
callq 0x4050
movq (%r14), %rdi
movq %r15, %rsi
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd909(%rip), %rsi      # 0xf02a
movq %r12, %rdx
movl $0x37, %ecx
callq 0x4050
movq (%r14), %rdi
testl %ebp, %ebp
je 0x173c
callq 0x1270
jmp 0x1741
callq 0x566c
leaq 0xd8c9(%rip), %rdi      # 0xf011
leaq 0xfd63(%rip), %rsi      # 0x114b2
leaq 0x8(%rsp), %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6ba1
movl %eax, %ebp
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd8d7(%rip), %rsi      # 0xf047
leaq 0xd89f(%rip), %r15      # 0xf016
movq %r15, %rdx
movl $0x3b, %ecx
callq 0x4050
movq (%r14), %rax
movq 0x30(%rax), %rdi
leaq 0xd872(%rip), %rsi      # 0xf004
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd8aa(%rip), %rsi      # 0xf050
movq %r15, %rdx
movl $0x3c, %ecx
callq 0x4050
movq (%r14), %rdi
testl %ebp, %ebp
je 0x17c1
callq 0x1270
jmp 0x17c6
callq 0x566c
movq %rbx, %rdi
callq 0x7052
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/combinators.c
// Function: test_check_withf
void test_check_withf(void) {
  int success;
  mpc_result_t  r;
  mpc_parser_t* p = mpc_check_withf(mpc_or(2, mpc_char('a'), mpc_char('b')), free, check_is, (void*)"a", "Expected '%s'", "a");

  success = mpc_parse("test", "a", p, &r);
  PT_ASSERT(success);
  if (success) PT_ASSERT_STR_EQ(r.output, "a");
  if (success) free(r.output); else mpc_err_delete(r.error);

  success = mpc_parse("test", "b", p, &r);
  PT_ASSERT(!success);
  if (!success) PT_ASSERT_STR_EQ(r.error->failure, "Expected 'a'");
  if (success) free(r.output); else mpc_err_delete(r.error);

  mpc_delete(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x61, %edi
callq 0x79a1
movq %rax, %rbx
movl $0x62, %edi
callq 0x79a1
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x807e
movq 0x167b6(%rip), %rsi     # 0x17fc8
leaq -0x1c0(%rip), %rdx      # 0x1659
leaq 0xd860(%rip), %r8       # 0xf080
leaq 0x10c55(%rip), %r14     # 0x1247c
movq %rax, %rdi
movq %r14, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x7da4
movq %rax, %rbx
leaq 0xd7d0(%rip), %rdi      # 0xf011
movq %rsp, %r15
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x6ba1
movl %eax, %ebp
leaq 0xd7ed(%rip), %rsi      # 0xf048
leaq 0xd7b4(%rip), %rdx      # 0xf016
movl %eax, %edi
movl $0x48, %ecx
callq 0x4050
movq (%r15), %rdi
testl %ebp, %ebp
je 0x18ac
leaq 0x10c00(%rip), %rsi     # 0x1247c
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd79a(%rip), %rsi      # 0xf02a
leaq 0xd77f(%rip), %rdx      # 0xf016
movl $0x49, %ecx
callq 0x4050
movq (%rsp), %rdi
callq 0x1270
jmp 0x18b1
callq 0x566c
leaq 0xd759(%rip), %rdi      # 0xf011
leaq 0xfbf3(%rip), %rsi      # 0x114b2
movq %rsp, %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6ba1
movl %eax, %ebp
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd769(%rip), %rsi      # 0xf047
leaq 0xd731(%rip), %rdx      # 0xf016
movl $0x4d, %ecx
callq 0x4050
movq (%r14), %rdi
testl %ebp, %ebp
je 0x18fd
callq 0x1270
jmp 0x1936
movq 0x30(%rdi), %rdi
leaq 0xd6fc(%rip), %rsi      # 0xf004
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd734(%rip), %rsi      # 0xf050
leaq 0xd6f3(%rip), %rdx      # 0xf016
movl $0x4e, %ecx
callq 0x4050
movq (%rsp), %rdi
callq 0x566c
movq %rbx, %rdi
callq 0x7052
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/combinators.c
// Function: suite_combinators
void suite_combinators(void) {
  pt_add_test(test_check,       "Test Check",        "Suite Combinators");
  pt_add_test(test_check_with,  "Test Check with",   "Suite Combinators");
  pt_add_test(test_checkf,      "Test Check F",      "Suite Combinators");
  pt_add_test(test_check_withf, "Test Check with F", "Suite Combinators");
}

// Assembly:
pushq %rbx
leaq -0x5e5(%rip), %rdi      # 0x136c
leaq 0xd736(%rip), %rsi      # 0xf08e
leaq 0xd73a(%rip), %rbx      # 0xf099
movq %rbx, %rdx
callq 0x40c7
leaq -0x47e(%rip), %rdi      # 0x14f0
leaq 0xd736(%rip), %rsi      # 0xf0ab
movq %rbx, %rdx
callq 0x40c7
leaq -0x317(%rip), %rdi      # 0x166d
leaq 0xd730(%rip), %rsi      # 0xf0bb
movq %rbx, %rdx
callq 0x40c7
leaq -0x1bf(%rip), %rdi      # 0x17db
leaq 0xd727(%rip), %rsi      # 0xf0c8
movq %rbx, %rdx
popq %rbx
jmp 0x40c7
nop
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/core.c
// Function: mpcf_maths
static mpc_val_t *mpcf_maths(int n, mpc_val_t **xs) {
  int **vs = (int**)xs;
  (void) n;

  switch(((char*)xs[1])[0])
  {
    case '*': { *vs[0] *= *vs[2]; }; break;
    case '/': { *vs[0] /= *vs[2]; }; break;
    case '%': { *vs[0] %= *vs[2]; }; break;
    case '+': { *vs[0] += *vs[2]; }; break;
    case '-': { *vs[0] -= *vs[2]; }; break;
    default: break;
  }

  free(xs[1]); free(xs[2]);

  return xs[0];
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
movzbl (%rdi), %eax
addl $-0x25, %eax
cmpl $0xa, %eax
ja 0x1f3d
leaq 0xd1f0(%rip), %rcx      # 0xf0dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rcx
movq 0x10(%rbx), %rsi
movl (%rcx), %eax
cltd
idivl (%rsi)
movl %edx, (%rcx)
jmp 0x1f3d
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rcx), %ecx
addl %ecx, (%rax)
jmp 0x1f3d
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rax), %edx
imull (%rcx), %edx
movl %edx, (%rax)
jmp 0x1f3d
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rcx), %ecx
subl %ecx, (%rax)
jmp 0x1f3d
movq (%rbx), %rcx
movq 0x10(%rbx), %rsi
movl (%rcx), %eax
cltd
idivl (%rsi)
movl %eax, (%rcx)
callq 0x1270
movq 0x10(%rbx), %rdi
callq 0x1270
movq (%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/core.c
// Function: test_strip
void test_strip(void) {

  mpc_parser_t *Stripperl = mpc_apply(mpc_many(mpcf_strfold, mpc_any()), mpcf_strtriml);
  mpc_parser_t *Stripperr = mpc_apply(mpc_many(mpcf_strfold, mpc_any()), mpcf_strtrimr);
  mpc_parser_t *Stripper  = mpc_apply(mpc_many(mpcf_strfold, mpc_any()), mpcf_strtrim);

  PT_ASSERT(mpc_test_pass(Stripperl, " asdmlm dasd  ", "asdmlm dasd  ", streq, free, strprint));
  PT_ASSERT(mpc_test_pass(Stripperr, " asdmlm dasd  ", " asdmlm dasd", streq, free, strprint));
  PT_ASSERT(mpc_test_pass(Stripper,  " asdmlm dasd  ", "asdmlm dasd", streq, free, strprint));

  mpc_delete(Stripperl);
  mpc_delete(Stripperr);
  mpc_delete(Stripper);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x7974
leaq 0x656d(%rip), %rbx      # 0x84f1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f8e
leaq 0x80bd(%rip), %rsi      # 0xa053
movq %rax, %rdi
callq 0x7b78
movq %rax, %r14
movq %rax, 0x10(%rsp)
callq 0x7974
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f8e
leaq 0x80e3(%rip), %rsi      # 0xa0a0
movq %rax, %rdi
callq 0x7b78
movq %rax, %r12
callq 0x7974
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f8e
leaq 0x8100(%rip), %rsi      # 0xa0df
movq %rax, %rdi
callq 0x7b78
movq %rax, 0x8(%rsp)
leaq 0xd489(%rip), %rbx      # 0xf47c
leaq 0xd483(%rip), %rdx      # 0xf47d
leaq -0x43a(%rip), %rbp      # 0x1bc7
movq 0x15fc0(%rip), %r8      # 0x17fc8
leaq -0x437(%rip), %r13      # 0x1bd8
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rcx
movq %r8, %r14
movq %r13, %r9
callq 0xaa3c
leaq 0xd461(%rip), %rsi      # 0xf48b
leaq 0xd113(%rip), %r15      # 0xf144
movl %eax, %edi
movq %r15, %rdx
movl $0x67, %ecx
callq 0x4050
leaq 0xd497(%rip), %rdx      # 0xf4de
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rcx
movq %r14, %r8
movq %r13, %r9
callq 0xaa3c
leaq 0xd489(%rip), %rsi      # 0xf4eb
movl %eax, %edi
movq %r15, %rdx
movl $0x68, %ecx
callq 0x4050
leaq 0xd467(%rip), %rdx      # 0xf4df
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
leaq 0xd3f5(%rip), %rsi      # 0xf47c
movq %rbp, %rcx
movq %r14, %r8
movq %r13, %r9
callq 0xaa3c
leaq 0xd4a1(%rip), %rsi      # 0xf53d
movl %eax, %edi
movq %r15, %rdx
movl $0x69, %ecx
callq 0x4050
movq 0x10(%rsp), %rdi
callq 0x7052
movq %r12, %rdi
callq 0x7052
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7052
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/core.c
// Function: test_repeat
void test_repeat(void) {

  int success;
  mpc_result_t r;
  mpc_parser_t *p = mpc_count(3, mpcf_strfold, mpc_digit(), free);

  success = mpc_parse("test", "046", p, &r);
  PT_ASSERT(success);
  PT_ASSERT_STR_EQ(r.output, "046");
  free(r.output);

  success = mpc_parse("test", "046aa", p, &r);
  PT_ASSERT(success);
  PT_ASSERT_STR_EQ(r.output, "046");
  free(r.output);

  success = mpc_parse("test", "04632", p, &r);
  PT_ASSERT(success);
  PT_ASSERT_STR_EQ(r.output, "046");
  free(r.output);

  success = mpc_parse("test", "04", p, &r);
  PT_ASSERT(!success);
  mpc_err_delete(r.error);

  mpc_delete(p);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x865b
leaq 0x6407(%rip), %rsi      # 0x84f1
movq 0x15ed7(%rip), %rcx     # 0x17fc8
movl $0x3, %edi
movq %rax, %rdx
callq 0x7ffa
movq %rax, %rbx
leaq 0xcf09(%rip), %r12      # 0xf011
leaq 0xd47e(%rip), %rbp      # 0xf58d
movq %rsp, %r14
movq %r12, %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x6ba1
leaq 0xcf1e(%rip), %rsi      # 0xf048
leaq 0xd013(%rip), %r15      # 0xf144
movl %eax, %edi
movq %r15, %rdx
movl $0x78, %ecx
callq 0x4050
movq (%r14), %rdi
movq %rbp, %rsi
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd437(%rip), %r13      # 0xf591
movq %r13, %rsi
movq %r15, %rdx
movl $0x79, %ecx
callq 0x4050
movq (%r14), %rdi
callq 0x1270
leaq 0xd437(%rip), %rsi      # 0xf5b0
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6ba1
movl %eax, %edi
leaq 0xceb8(%rip), %rsi      # 0xf048
movq %r15, %rdx
movl $0x7d, %ecx
callq 0x4050
movq (%r14), %rdi
movq %rbp, %rsi
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
movq %r13, %rsi
movq %r15, %rdx
movl $0x7e, %ecx
callq 0x4050
movq (%r14), %rdi
callq 0x1270
leaq 0xd3e7(%rip), %rsi      # 0xf5b6
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6ba1
movl %eax, %edi
leaq 0xce62(%rip), %rsi      # 0xf048
movq %r15, %rdx
movl $0x82, %ecx
callq 0x4050
movq (%r14), %rdi
movq %rbp, %rsi
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
movq %r13, %rsi
movq %r15, %rdx
movl $0x83, %ecx
callq 0x4050
movq (%r14), %rdi
callq 0x1270
leaq 0xd397(%rip), %rsi      # 0xf5bc
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6ba1
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xce05(%rip), %rsi      # 0xf047
movq %r15, %rdx
movl $0x87, %ecx
callq 0x4050
movq (%r14), %rdi
callq 0x566c
movq %rbx, %rdi
callq 0x7052
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/core.c
// Function: test_reader
void test_reader(void) {

  mpc_parser_t* Line = mpc_many(
    mpcf_strfold,
    mpc_apply(mpc_re("[^\\n]*(\\n|$)"), read_line));

  line_count = 0;

  PT_ASSERT(mpc_test_pass(Line,
    "hello\nworld\n\nthis\nis\ndan",
    "hello\nworld\n\nthis\nis\ndan", streq, free, strprint));

  PT_ASSERT(line_count == 6);

  line_count = 0;

  PT_ASSERT(mpc_test_pass(Line,
    "abcHVwufvyuevuy3y436782\n\n\nrehre\nrew\n-ql.;qa\neg",
    "abcHVwufvyuevuy3y436782\n\n\nrehre\nrew\n-ql.;qa\neg", streq, free, strprint));

  PT_ASSERT(line_count == 7);

  mpc_delete(Line);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xd160(%rip), %rdi      # 0xf63d
callq 0x92b6
leaq 0xfe(%rip), %rsi        # 0x25e7
movq %rax, %rdi
callq 0x7b78
leaq 0x5ff9(%rip), %rdi      # 0x84f1
movq %rax, %rsi
callq 0x7f8e
movq %rax, %rbx
xorl %ebp, %ebp
movl %ebp, 0x15cd9(%rip)     # 0x181e4
leaq 0xd138(%rip), %rdx      # 0xf64a
leaq -0x952(%rip), %r15      # 0x1bc7
movq 0x15aa8(%rip), %r12     # 0x17fc8
leaq -0x94f(%rip), %r13      # 0x1bd8
movq %rax, %rdi
movq %rdx, %rsi
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0xaa3c
leaq 0xd121(%rip), %rsi      # 0xf663
leaq 0xcbfb(%rip), %r14      # 0xf144
movl %eax, %edi
movq %r14, %rdx
movl $0xc5, %ecx
callq 0x4050
xorl %edi, %edi
cmpl $0x6, 0x15c83(%rip)     # 0x181e4
sete %dil
leaq 0xd164(%rip), %rsi      # 0xf6d0
movq %r14, %rdx
movl $0xc7, %ecx
callq 0x4050
movl %ebp, 0x15c65(%rip)     # 0x181e4
leaq 0xd15a(%rip), %rdx      # 0xf6e0
movq %rbx, %rdi
movq %rdx, %rsi
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0xaa3c
leaq 0xd16e(%rip), %rsi      # 0xf70f
movl %eax, %edi
movq %r14, %rdx
movl $0xcd, %ecx
callq 0x4050
xorl %edi, %edi
cmpl $0x7, 0x15c2b(%rip)     # 0x181e4
sete %dil
leaq 0xd1e6(%rip), %rsi      # 0xf7aa
movq %r14, %rdx
movl $0xcf, %ecx
callq 0x4050
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7052
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/core.c
// Function: test_tokens
void test_tokens(void) {

  mpc_parser_t* Tokens = mpc_many(
    mpcf_strfold,
    mpc_apply(mpc_strip(mpc_re("\\s*([a-zA-Z_]+|[0-9]+|,|\\.|:)")), print_token));

  token_count = 0;

  PT_ASSERT(mpc_test_pass(Tokens,
    "  hello 4352 ,  \n foo.bar   \n\n  test:ing   ",
    "hello4352,foo.bartest:ing", streq, free, strprint));

  PT_ASSERT(token_count == 9);

  mpc_delete(Tokens);

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xd1be(%rip), %rdi      # 0xf7ba
callq 0x92b6
movq %rax, %rdi
callq 0x90bb
leaq 0x9c(%rip), %rsi        # 0x26ac
movq %rax, %rdi
callq 0x7b78
leaq 0x5ed2(%rip), %rdi      # 0x84f1
movq %rax, %rsi
callq 0x7f8e
movq %rax, %rbx
movl $0x0, 0x15bb4(%rip)     # 0x181e8
leaq 0xd19d(%rip), %rsi      # 0xf7d8
leaq 0xd1c2(%rip), %rdx      # 0xf804
leaq -0xa82(%rip), %rcx      # 0x1bc7
movq 0x15978(%rip), %r8      # 0x17fc8
leaq -0xa7f(%rip), %r9       # 0x1bd8
movq %rax, %rdi
callq 0xaa3c
leaq 0xd1b8(%rip), %rsi      # 0xf81e
leaq 0xcad7(%rip), %r14      # 0xf144
movl %eax, %edi
movq %r14, %rdx
movl $0xe7, %ecx
callq 0x4050
xorl %edi, %edi
cmpl $0x9, 0x15b63(%rip)     # 0x181e8
sete %dil
leaq 0xd20a(%rip), %rsi      # 0xf89a
movq %r14, %rdx
movl $0xe9, %ecx
callq 0x4050
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7052
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/core.c
// Function: test_eoi
void test_eoi(void) {

  mpc_parser_t* Line = mpc_re("[^\\n]*$");

  PT_ASSERT(mpc_test_pass(Line, "blah", "blah", streq, free, strprint));
  PT_ASSERT(mpc_test_pass(Line, "blah\n", "blah\n", streq, free, strprint));

  mpc_delete(Line);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xd1e5(%rip), %rdi      # 0xf8ab
callq 0x92b6
movq %rax, %rbx
leaq 0xe410(%rip), %rdx      # 0x10ae5
leaq -0xb15(%rip), %r14      # 0x1bc7
movq 0x158e5(%rip), %r15     # 0x17fc8
leaq -0xb12(%rip), %r12      # 0x1bd8
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xaa3c
leaq 0xd1ae(%rip), %rsi      # 0xf8b3
leaq 0xca38(%rip), %r13      # 0xf144
movl %eax, %edi
movq %r13, %rdx
movl $0xf3, %ecx
callq 0x4050
leaq 0xf2d2(%rip), %rdx      # 0x119f4
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xaa3c
leaq 0xd1b1(%rip), %rsi      # 0xf8ee
movl %eax, %edi
movq %r13, %rdx
movl $0xf4, %ecx
callq 0x4050
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7052
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/core.c
// Function: suite_core
void suite_core(void) {
  pt_add_test(test_ident,  "Test Ident",  "Suite Core");
  pt_add_test(test_maths,  "Test Maths",  "Suite Core");
  pt_add_test(test_strip,  "Test Strip",  "Suite Core");
  pt_add_test(test_repeat, "Test Repeat", "Suite Core");
  pt_add_test(test_copy,   "Test Copy",   "Suite Core");
  pt_add_test(test_reader, "Test Reader", "Suite Core");
  pt_add_test(test_tokens, "Test Tokens", "Suite Core");
  pt_add_test(test_eoi,    "Test EOI",    "Suite Core");
  pt_add_test(test_sepby,  "Test SepBy",  "Suite Core");
}

// Assembly:
pushq %rbx
leaq -0x104e(%rip), %rdi     # 0x19ac
leaq 0xd15a(%rip), %rsi      # 0xfb5b
leaq 0xd15e(%rip), %rbx      # 0xfb66
movq %rbx, %rdx
callq 0x40c7
leaq -0xe2e(%rip), %rdi      # 0x1be9
leaq 0xd153(%rip), %rsi      # 0xfb71
movq %rbx, %rdx
callq 0x40c7
leaq -0xac3(%rip), %rdi      # 0x1f6a
leaq 0xd148(%rip), %rsi      # 0xfb7c
movq %rbx, %rdx
callq 0x40c7
leaq -0x970(%rip), %rdi      # 0x20d3
leaq 0xd13d(%rip), %rsi      # 0xfb87
movq %rbx, %rdx
callq 0x40c7
leaq -0x7eb(%rip), %rdi      # 0x226e
leaq 0xd133(%rip), %rsi      # 0xfb93
movq %rbx, %rdx
callq 0x40c7
leaq -0x5a4(%rip), %rdi      # 0x24cb
leaq 0xd127(%rip), %rsi      # 0xfb9d
movq %rbx, %rdx
callq 0x40c7
leaq -0x494(%rip), %rdi      # 0x25f1
leaq 0xd11d(%rip), %rsi      # 0xfba9
movq %rbx, %rdx
callq 0x40c7
leaq -0x3e5(%rip), %rdi      # 0x26b6
leaq 0xd113(%rip), %rsi      # 0xfbb5
movq %rbx, %rdx
callq 0x40c7
leaq -0x354(%rip), %rdi      # 0x275d
leaq 0xd106(%rip), %rsi      # 0xfbbe
movq %rbx, %rdx
popq %rbx
jmp 0x40c7
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/grammar.c
// Function: test_language
void test_language(void) {
  
  mpc_parser_t *Expr, *Prod, *Value, *Maths;
  
  Expr  = mpc_new("expression");
  Prod  = mpc_new("product");
  Value = mpc_new("value");
  Maths = mpc_new("maths");
  
  mpca_lang(MPCA_LANG_DEFAULT,
    " expression : <product> (('+' | '-') <product>)*; "
    " product : <value>   (('*' | '/')   <value>)*;    "
    " value : /[0-9]+/ | '(' <expression> ')';         "
    " maths : /^/ <expression> /$/;                    ",
    Expr, Prod, Value, Maths);
  
  mpc_cleanup(4, Expr, Prod, Value, Maths);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xccdf(%rip), %rdi      # 0xfbce
callq 0x7191
movq %rax, %rbx
leaq 0xccdb(%rip), %rdi      # 0xfbd9
callq 0x7191
movq %rax, %r14
leaq 0xccd4(%rip), %rdi      # 0xfbe1
callq 0x7191
movq %rax, %r15
leaq 0xc3de(%rip), %rdi      # 0xf2fa
callq 0x7191
movq %rax, %r12
leaq 0xd07c(%rip), %rsi      # 0xffa7
xorl %edi, %edi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xcd98
movl $0x4, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x75e0
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/grammar.c
// Function: test_language_file
void test_language_file(void) {
  
  mpc_parser_t *Expr, *Prod, *Value, *Maths;
  
  Expr  = mpc_new("expression");
  Prod  = mpc_new("product");
  Value = mpc_new("value");
  Maths = mpc_new("maths");
  
  mpca_lang_contents(MPCA_LANG_DEFAULT, "./tests/maths.grammar", Expr, Prod, Value, Maths);
  
  mpc_cleanup(4, Expr, Prod, Value, Maths);
  
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xcc5c(%rip), %rdi      # 0xfbce
callq 0x7191
movq %rax, %rbx
leaq 0xcc58(%rip), %rdi      # 0xfbd9
callq 0x7191
movq %rax, %r14
leaq 0xcc51(%rip), %rdi      # 0xfbe1
callq 0x7191
movq %rax, %r15
leaq 0xc35b(%rip), %rdi      # 0xf2fa
callq 0x7191
movq %rax, %r12
leaq 0xd0c2(%rip), %rsi      # 0x10070
xorl %edi, %edi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xce72
movl $0x4, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x75e0
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/grammar.c
// Function: test_missingrule
void test_missingrule(void) {
  
  int result;
  mpc_err_t *err;
  mpc_result_t r;
  mpc_parser_t *Parser = mpc_new("parser");
  
  err = mpca_lang(MPCA_LANG_DEFAULT,
    "parser        : /^/ (<missing>)* /$/ ;\n",
    Parser, NULL);
  
  PT_ASSERT(err == NULL);
  
  result = mpc_parse("<stdin>", "test", Parser, &r);
  
  PT_ASSERT(result == 0);
  PT_ASSERT(r.error != NULL);
  PT_ASSERT(strcmp(r.error->failure, "Unknown Parser 'missing'!") == 0);
  
  mpc_err_delete(r.error);
  mpc_cleanup(1, Parser);

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xca6b(%rip), %rdi      # 0x10327
callq 0x7191
movq %rax, %rbx
leaq 0xd108(%rip), %rsi      # 0x109d3
xorl %edi, %edi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xcd98
xorl %edi, %edi
testq %rax, %rax
sete %dil
leaq 0xcae3(%rip), %rsi      # 0x103cc
leaq 0xc44a(%rip), %r14      # 0xfd3a
movq %r14, %rdx
movl $0x110, %ecx            # imm = 0x110
callq 0x4050
leaq 0xd0f7(%rip), %rdi      # 0x109fb
leaq 0xb706(%rip), %rsi      # 0xf011
leaq 0x8(%rsp), %r15
movq %rbx, %rdx
movq %r15, %rcx
callq 0x6ba1
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd0d9(%rip), %rsi      # 0x10a03
movq %r14, %rdx
movl $0x114, %ecx            # imm = 0x114
callq 0x4050
xorl %edi, %edi
cmpq $0x0, (%r15)
setne %dil
leaq 0xd0c7(%rip), %rsi      # 0x10a0f
movq %r14, %rdx
movl $0x115, %ecx            # imm = 0x115
callq 0x4050
movq (%r15), %rax
movq 0x30(%rax), %rdi
leaq 0xd0bc(%rip), %rsi      # 0x10a1f
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd0c2(%rip), %rsi      # 0x10a39
movq %r14, %rdx
movl $0x116, %ecx            # imm = 0x116
callq 0x4050
movq (%r15), %rdi
callq 0x566c
movl $0x1, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x75e0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/grammar.c
// Function: suite_grammar
void suite_grammar(void) {
  pt_add_test(test_grammar, "Test Grammar", "Suite Grammar");
  pt_add_test(test_language, "Test Language", "Suite Grammar");
  pt_add_test(test_language_file, "Test Language File", "Suite Grammar");
  pt_add_test(test_doge, "Test Doge", "Suite Grammar");
  pt_add_test(test_partial, "Test Partial", "Suite Grammar");
  pt_add_test(test_qscript, "Test QScript", "Suite Grammar");
  pt_add_test(test_missingrule, "Test Missing Rule", "Suite Grammar");
  pt_add_test(test_regex_mode, "Test Regex Mode", "Suite Grammar");
  pt_add_test(test_digits_file, "Test Digits File", "Suite Grammar");
}

// Assembly:
pushq %rbx
leaq -0x14c2(%rip), %rdi     # 0x2ac4
leaq 0xcebe(%rip), %rsi      # 0x10e4b
leaq 0xcec4(%rip), %rbx      # 0x10e58
movq %rbx, %rdx
callq 0x40c7
leaq -0x10c3(%rip), %rdi     # 0x2ee0
leaq 0xcebc(%rip), %rsi      # 0x10e66
movq %rbx, %rdx
callq 0x40c7
leaq -0x1056(%rip), %rdi     # 0x2f63
leaq 0xceb4(%rip), %rsi      # 0x10e74
movq %rbx, %rdx
callq 0x40c7
leaq -0xfe9(%rip), %rdi      # 0x2fe6
leaq 0xceb1(%rip), %rsi      # 0x10e87
movq %rbx, %rdx
callq 0x40c7
leaq -0xdfb(%rip), %rdi      # 0x31ea
leaq 0xcea5(%rip), %rsi      # 0x10e91
movq %rbx, %rdx
callq 0x40c7
leaq -0xc09(%rip), %rdi      # 0x33f2
leaq 0xce9c(%rip), %rsi      # 0x10e9e
movq %rbx, %rdx
callq 0x40c7
leaq -0x765(%rip), %rdi      # 0x38ac
leaq 0xce93(%rip), %rsi      # 0x10eab
movq %rbx, %rdx
callq 0x40c7
leaq -0x682(%rip), %rdi      # 0x39a5
leaq 0xce8f(%rip), %rsi      # 0x10ebd
movq %rbx, %rdx
callq 0x40c7
leaq -0x3ea(%rip), %rdi      # 0x3c53
leaq 0xce89(%rip), %rsi      # 0x10ecd
movq %rbx, %rdx
popq %rbx
jmp 0x40c7
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/ptest.c
// Function: pt_assert_run
void pt_assert_run(int result, const char* expr, const char* file, int line) {

  num_asserts++;
  test_passing = test_passing && result;

  if (result) {
    num_assert_passes++;
  } else {
    sprintf(assert_err_buff,
      "        %i. Assert [ %s ] (%s:%i)\n",
      assert_err_num+1, expr, file, line );
    strcat(assert_err, assert_err_buff);
    assert_err_num++;
    num_assert_fails++;
  }

}

// Assembly:
pushq %rbx
incl 0x14199(%rip)           # 0x181f0
movq %rdx, %r8
cmpl $0x0, 0x14193(%rip)     # 0x181f4
setne %al
testl %edi, %edi
setne %dl
andb %al, %dl
movzbl %dl, %eax
movl %eax, 0x14180(%rip)     # 0x181f4
testl %edi, %edi
je 0x4081
leaq 0x14179(%rip), %rax     # 0x181f8
jmp 0x40c3
movl %ecx, %r9d
movq %rsi, %rcx
movl 0x14973(%rip), %edx     # 0x18a00
incl %edx
leaq 0x1416a(%rip), %rbx     # 0x18200
leaq 0xce4b(%rip), %rsi      # 0x10ee8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1220
leaq 0x14962(%rip), %rdi     # 0x18a10
movq %rbx, %rsi
callq 0x1210
incl 0x14944(%rip)           # 0x18a00
leaq 0x1514d(%rip), %rax     # 0x19210
incl (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/ptest.c
// Function: pt_add_test
void pt_add_test(void (*func)(void), const char* name, const char* suite) {

  test_t test;

  if (num_tests == MAX_TESTS) {
    printf("ERROR: Exceeded maximum test count of %i!\n",
      MAX_TESTS); abort();
  }

  if (strlen(name) >= MAX_NAME) {
    printf("ERROR: Test name '%s' too long (Maximum is %i characters)\n",
      name, MAX_NAME); abort();
  }

  if (strlen(suite) >= MAX_NAME) {
    printf("ERROR: Test suite '%s' too long (Maximum is %i characters)\n",
      suite, MAX_NAME); abort();
  }

  test.func = func;
  pt_title_case(test.name, name);
  pt_title_case(test.suite, suite);

  tests[num_tests] = test;
  num_tests++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movslq 0x15138(%rip), %r12     # 0x19214
cmpq $0x800, %r12            # imm = 0x800
je 0x4177
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x10b0
cmpq $0x200, %rax            # imm = 0x200
jae 0x418f
movq %rbx, %rdi
callq 0x10b0
cmpq $0x200, %rax            # imm = 0x200
jae 0x419b
leaq 0x8(%rsp), %rdi
movq %r15, -0x8(%rdi)
movq %r14, %rsi
callq 0x41b6
leaq 0x208(%rsp), %rdi
movq %rbx, %rsi
callq 0x41b6
movq %r12, %rax
shlq $0xa, %rax
leaq (%rax,%r12,8), %rax
leaq 0x150d3(%rip), %rdi     # 0x19220
addq %rax, %rdi
movq %rsp, %rsi
movl $0x408, %edx            # imm = 0x408
callq 0x1180
leal 0x1(%r12), %eax
movl %eax, 0x150ac(%rip)     # 0x19214
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xcd8d(%rip), %rdi      # 0x10f0b
movl $0x800, %esi            # imm = 0x800
xorl %eax, %eax
callq 0x10d0
callq 0x1040
leaq 0xcda0(%rip), %rdi      # 0x10f36
movq %r14, %rsi
jmp 0x41a5
leaq 0xcdcf(%rip), %rdi      # 0x10f71
movq %rbx, %rsi
movl $0x200, %edx            # imm = 0x200
xorl %eax, %eax
callq 0x10d0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/ptest.c
// Function: pt_title_case
static void pt_title_case(char* output, const char* input) {

  int space = 1;
  unsigned int i;

  strcpy(output, input);

  for(i = 0; i < strlen(output); i++) {

    if (output[i] == '_' || output[i] == ' ') {
      space = 1;
      output[i] = ' ';
      continue;
    }

    if (space && output[i] >= 'a' && output[i] <= 'z') {
      space = 0;
      output[i] = output[i] - 32;
      continue;
    }

    space = 0;

  }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1060
cmpb $0x0, (%rbx)
je 0x421d
movl $0x1, %ebp
xorl %r14d, %r14d
movl $0x1, %ecx
movzbl (%rbx,%r14), %eax
movb $0x20, %dl
movl $0x1, %r15d
cmpl $0x20, %eax
je 0x4204
cmpl $0x5f, %eax
je 0x4204
xorl %r15d, %r15d
testl %ecx, %ecx
je 0x4208
leal -0x61(%rax), %ecx
cmpb $0x19, %cl
ja 0x4208
addb $-0x20, %al
xorl %r15d, %r15d
movl %eax, %edx
movb %dl, (%rbx,%r14)
movl %ebp, %r14d
movq %rbx, %rdi
callq 0x10b0
incl %ebp
movl %r15d, %ecx
cmpq %r14, %rax
ja 0x41d7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/ptest.c
// Function: ptest_signal
static void ptest_signal(int sig) {

  test_passing = 0;

  switch( sig ) {
    case SIGFPE:  sprintf(assert_err_buff,
      "        %i. Division by Zero\n", assert_err_num+1);
    break;
    case SIGILL:  sprintf(assert_err_buff,
      "        %i. Illegal Instruction\n", assert_err_num+1);
    break;
    case SIGSEGV: sprintf(assert_err_buff,
      "        %i. Segmentation Fault\n", assert_err_num+1);
    break;
    default: break;
  }

  assert_err_num++;
  strcat(assert_err, assert_err_buff);

  pt_color(RED);
  printf("Failed! \n\n%s\n", assert_err);
  pt_color(DEFAULT);

  puts("    | Stopping Execution.");
  fflush(stdout);
  exit(0);

}

// Assembly:
pushq %rbx
movl $0x0, 0x13a94(%rip)     # 0x181f4
cmpl $0xb, %edi
je 0x4781
cmpl $0x8, %edi
je 0x4778
cmpl $0x4, %edi
jne 0x479e
leaq 0xcaa6(%rip), %rsi      # 0x1121c
jmp 0x4788
leaq 0xca7f(%rip), %rsi      # 0x111fe
jmp 0x4788
leaq 0xcab5(%rip), %rsi      # 0x1123d
movl 0x14272(%rip), %edx     # 0x18a00
incl %edx
leaq 0x13a69(%rip), %rdi     # 0x18200
xorl %eax, %eax
callq 0x1220
incl 0x1425c(%rip)           # 0x18a00
leaq 0x14265(%rip), %rbx     # 0x18a10
leaq 0x13a4e(%rip), %rsi     # 0x18200
movq %rbx, %rdi
callq 0x1210
movl $0x4, %edi
callq 0x4801
leaq 0xc907(%rip), %rdi      # 0x110d2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10d0
movl $0x10, %edi
callq 0x4801
leaq 0xca77(%rip), %rdi      # 0x1125d
callq 0x1070
movq 0x137ee(%rip), %rax     # 0x17fe0
movq (%rax), %rdi
callq 0x11a0
xorl %edi, %edi
callq 0x1230
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/regex.c
// Function: test_regex_range
void test_regex_range(void) {

  mpc_parser_t *re0, *re1, *re2, *re3;

  re0 = mpc_re("abg[abcdef]");
  re1 = mpc_re("y*[a-z]");
  re2 = mpc_re("zz(p+)?[A-Z_0\\]123]*");
  re3 = mpc_re("^[^56hy].*$");

  /* TODO: Testing */

  mpc_delete(re0);
  mpc_delete(re1);
  mpc_delete(re2);
  mpc_delete(re3);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xc883(%rip), %rdi      # 0x11718
callq 0x92b6
movq %rax, %rbx
leaq 0xc880(%rip), %rdi      # 0x11724
callq 0x92b6
movq %rax, %r14
leaq 0xc879(%rip), %rdi      # 0x1172c
callq 0x92b6
movq %rax, %r15
leaq 0xc87f(%rip), %rdi      # 0x11741
callq 0x92b6
movq %rax, %r12
movq %rbx, %rdi
callq 0x7052
movq %r14, %rdi
callq 0x7052
movq %r15, %rdi
callq 0x7052
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7052
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/tests/regex.c
// Function: test_regex_string
void test_regex_string(void) {

  mpc_parser_t *re0 = mpc_re("\"(\\\\.|[^\"])*\"");

  PT_ASSERT(regex_test_pass(re0, "\"there\"", "\"there\""));
  PT_ASSERT(regex_test_pass(re0, "\"hello\"", "\"hello\""));
  PT_ASSERT(regex_test_pass(re0, "\"i am dan\"", "\"i am dan\""));
  PT_ASSERT(regex_test_pass(re0, "\"i a\\\"m dan\"", "\"i a\\\"m dan\""));

  mpc_delete(re0);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xc848(%rip), %rdi      # 0x1174d
callq 0x92b6
movq %rax, %rbx
leaq 0xc847(%rip), %rdx      # 0x1175b
leaq -0x6e1(%rip), %r14      # 0x483a
movq 0x130a6(%rip), %r15     # 0x17fc8
leaq -0x6de(%rip), %r12      # 0x484b
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xaa3c
leaq 0xc81f(%rip), %rsi      # 0x11763
leaq 0xc40e(%rip), %r13      # 0x11359
movl %eax, %edi
movq %r13, %rdx
movl $0x67, %ecx
callq 0x4050
leaq 0xc831(%rip), %rdx      # 0x11792
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xaa3c
leaq 0xc81e(%rip), %rsi      # 0x1179a
movl %eax, %edi
movq %r13, %rdx
movl $0x68, %ecx
callq 0x4050
leaq 0xc837(%rip), %rdx      # 0x117c9
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xaa3c
leaq 0xc827(%rip), %rsi      # 0x117d4
movl %eax, %edi
movq %r13, %rdx
movl $0x69, %ecx
callq 0x4050
leaq 0xc846(%rip), %rdx      # 0x11809
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xaa3c
leaq 0xc838(%rip), %rsi      # 0x11816
movl %eax, %edi
movq %r13, %rdx
movl $0x6a, %ecx
callq 0x4050
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7052