LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/igaw[P]jitterdebugger/jd_utils.c
// Function: cpuset_parse
ssize_t cpuset_parse(cpu_set_t *set, const char *str)
{
	unsigned int i, first, last;
	ssize_t len_next;
	long int num = 0;
	size_t len = 0;

	if (!strncmp(str, "0x", 2)) {
		num = _cpuset_parse_num(str, 16, &len);
		cpuset_from_bits(set, (unsigned long) num);
		return len;
	}

	num = _cpuset_parse_num(str, 10, &len);

	str += len;
	first = num;

	if (str[0] == '-') {
		num = _cpuset_parse_num(str + 1, 10, &len);
		str += 1 + len;
		last = len ? num + 1 : CPU_SETSIZE; /* "x-" means x-CPU_SIZE */
	} else
		last = first + 1;

	if (CPU_SETSIZE < last) {
		warn_handler("cpu num %d bigger than CPU_SETSIZE(%u), reducing",
			     last, CPU_SETSIZE);
		last = CPU_SETSIZE;
	}

	for (i = first; i < last; i++)
		CPU_SET(i, set);

	if (str[0] == ',') {
		len_next = cpuset_parse(set, str + 1);
		if (len_next < 0)
			return len_next;

		len += len_next;
	}

	return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
andq $0x0, (%rsp)
movq %rsi, %r12
movq %rdi, %rbx
cmpb $0x30, (%rsi)
jne 0x2838
cmpb $0x78, 0x1(%r12)
jne 0x2838
pushq $0x10
popq %rsi
movq %rsp, %rdx
movq %r12, %rdi
callq 0x2907
xorl %ecx, %ecx
pushq $0x1
popq %rdx
cmpq $0x40, %rcx
je 0x28f7
movq %rdx, %rsi
shlq %cl, %rsi
btq %rcx, %rax
jae 0x2833
orq %rsi, (%rbx)
incq %rcx
jmp 0x281a
pushq $0xa
popq %rsi
movq %rsp, %r14
movq %r12, %rdi
movq %r14, %rdx
callq 0x2907
movq %rax, %r15
movq (%r14), %rax
leaq (%r12,%rax), %r14
cmpb $0x2d, (%r12,%rax)
jne 0x287d
leaq 0x1(%r14), %rdi
pushq $0xa
popq %rsi
movq %rsp, %r12
movq %r12, %rdx
callq 0x2907
movq (%r12), %rcx
addq %rcx, %r14
incq %r14
testq %rcx, %rcx
jne 0x2880
jmp 0x28ad
movq %r15, %rax
incl %eax
cmpl $0x401, %eax            # imm = 0x401
jb 0x28b2
leaq 0x178a(%rip), %rdi      # 0x401a
leaq 0x17be(%rip), %rsi      # 0x4055
leaq 0x17c2(%rip), %rdx      # 0x4060
movl %eax, %ecx
movl $0x400, %r8d            # imm = 0x400
xorl %eax, %eax
callq 0x2516
movl $0x400, %eax            # imm = 0x400
movl %r15d, %ecx
movl %eax, %eax
pushq $0x1
popq %rdx
cmpq %rax, %rcx
jae 0x28d5
movq %rdx, %rsi
shlq %cl, %rsi
movq %rcx, %rdi
shrq $0x6, %rdi
orq %rsi, (%rbx,%rdi,8)
incq %rcx
jmp 0x28ba
cmpb $0x2c, (%r14)
jne 0x28f7
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27e7
testq %rax, %rax
js 0x28fb
movq (%rsp), %rcx
addq %rcx, %rax
jmp 0x28fb
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/igaw[P]jitterdebugger/jd_utils.c
// Function: cpuset_parse_num
static long int _cpuset_parse_num(const char *str, int base, size_t *len)
{
	long int ret;

	ret = parse_num(str, base, len);
	if (ret < 0)
		err_abort("cpuset: unable to parse string %s", str);

	return ret;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x25ae
testq %rax, %rax
js 0x2917
popq %rbx
retq
movq 0x36da(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x17da(%rip), %rsi      # 0x4102
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2150
pushq $0x1
popq %rdi
callq 0x2210
// File: /workspace/github_c_makefile_star2_O2/igaw[P]jitterdebugger/jd_utils.c
// Function: sysfs_load_str
int sysfs_load_str(const char *path, char **buf)
{
	int fd, ret;
	size_t len;

	fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY));
	if (fd < 0)
		return -errno;

	len = sysconf(_SC_PAGESIZE);

	*buf = malloc(len);
	if (!*buf) {
		ret = -ENOMEM;
		goto out_fd;
	}

	ret = read(fd, *buf, len - 1);
	if (ret < 0) {
		ret = -errno;
		goto out_buf;
	}

	(*buf)[ret] = 0;
out_buf:
	if (ret < 0)
		free(*buf);
out_fd:
	close(fd);
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x21c0
cmpl $-0x1, %eax
jne 0x2962
callq 0x2050
cmpl $0x4, (%rax)
je 0x2945
jmp 0x29b2
movl %eax, %ebx
testl %eax, %eax
js 0x29ad
pushq $0x1e
popq %rdi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
callq 0x2180
movq %rax, (%r14)
testq %rax, %rax
je 0x29ba
decq %r15
movl %ebx, %edi
movq %rax, %rsi
movq %r15, %rdx
callq 0x2120
movq %rax, %r15
testl %r15d, %r15d
js 0x29c0
movq (%r14), %rax
movl %r15d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movb $0x0, (%rax,%rcx)
jmp 0x29d9
callq 0x2050
xorl %r15d, %r15d
subl (%rax), %r15d
jmp 0x29e0
pushq $-0xc
popq %r15
jmp 0x29d9
callq 0x2050
movl (%rax), %eax
movl %eax, %r15d
negl %r15d
testl %eax, %eax
jle 0x29d9
movq (%r14), %rdi
callq 0x2030
movl %ebx, %edi
callq 0x2100
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2240
testq %rax, %rax
je 0x29f6
popq %rcx
retq
callq 0x2050
movl (%rax), %edi
leaq 0x1669(%rip), %rsi      # 0x406d
leaq 0x164a(%rip), %rdx      # 0x4055
leaq 0x166d(%rip), %rcx      # 0x407f
xorl %eax, %eax
callq 0x2449
// File: /workspace/github_c_makefile_star2_O2/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 0x29e9
movq %rax, %r14
movq %rax, %rdi
callq 0x2160
leaq 0x1647(%rip), %rsi      # 0x4089
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x21a0
testl %eax, %eax
js 0x2a87
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x21d0
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 0x15fa(%rip), %rsi      # 0x408f
leaq 0x15b9(%rip), %rdx      # 0x4055
leaq 0x1600(%rip), %rcx      # 0x40a3
xorl %eax, %eax
callq 0x2449
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x15e4(%rip), %rsi      # 0x40ac
callq 0x21d0
testq %rax, %rax
je 0x2b6f
movq %rax, %r14
leaq 0x17d1(%rip), %rdx      # 0x42b1
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a19
testq %rax, %rax
je 0x2b78
movq %rax, %r15
movq %rsp, %r12
pushq $0x1
popq %r13
movl $0x2000, %edx           # imm = 0x2000
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x2090
testq %rax, %rax
je 0x2b4e
movq %rax, %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x2220
cmpq %rbp, %rax
je 0x2afe
leaq 0x15a8(%rip), %rdi      # 0x40de
leaq 0x1518(%rip), %rsi      # 0x4055
leaq 0x1594(%rip), %rdx      # 0x40d8
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2516
movq %r15, %rdi
callq 0x20b0
movq %r14, %rdi
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
leaq 0x1538(%rip), %rdi      # 0x40ae
jmp 0x2b86
xorl %edi, %edi
callq 0x20b0
leaq 0x1558(%rip), %rdi      # 0x40de
leaq 0x14c8(%rip), %rsi      # 0x4055
leaq 0x1544(%rip), %rdx      # 0x40d8
movq %rbx, %rcx
xorl %eax, %eax
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2516
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
leaq 0x1577(%rip), %rsi      # 0x4145
leaq 0x16dc(%rip), %rdx      # 0x42b1
callq 0x2a19
movq %rax, %r14
testq %rax, %rax
jne 0x2c08
callq 0x2050
movl (%rax), %edi
movq (%r15), %r8
leaq 0x155e(%rip), %rsi      # 0x4151
leaq 0x158c(%rip), %rdx      # 0x4186
leaq 0x1596(%rip), %rcx      # 0x4197
xorl %eax, %eax
callq 0x2449
leaq 0xc(%rsp), %r15
pushq $0x1c
popq %r12
pushq $0x1
popq %r13
leaq 0x1586(%rip), %rbp      # 0x41a2
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x2090
testq %rax, %rax
je 0x2c54
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
movq %r14, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2150
jmp 0x2c1c
movq %r14, %rdi
callq 0x20b0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2cbf
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x2c8f
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2130
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x2ce3
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3332(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0x14e5(%rip), %rdi      # 0x41b5
pushq $0x1c
popq %rsi
pushq $0x1
popq %rdx
callq 0x2220
pushq $0x1
popq %rdi
callq 0x2210
movq 0x330e(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0x14de(%rip), %rdi      # 0x41d2
pushq $0x20
jmp 0x2cd2
// File: /workspace/github_c_makefile_star2_O2/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 0x3452(%rip), %rbx      # 0x6180
movq (%rbx), %r14
testq %r14, %r14
je 0x2d65
callq *0x8(%r14)
addq $0x8, %rbx
testl %eax, %eax
je 0x2d2e
movq 0x32af(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0x14df(%rip), %rsi      # 0x4235
xorl %eax, %eax
callq 0x2150
pushq $0x1
popq %rdi
callq 0x2210
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13a9(%rip), %rdi      # 0x4473
callq 0x2070
leaq 0x13bb(%rip), %rdi      # 0x4491
callq 0x2070
pushq $0xa
popq %rdi
callq 0x2040
leaq 0x13de(%rip), %rdi      # 0x44c8
callq 0x2070
leaq 0x13d9(%rip), %rdi      # 0x44cf
callq 0x2070
leaq 0x13eb(%rip), %rdi      # 0x44ed
callq 0x2070
leaq 0x140f(%rip), %rdi      # 0x451d
callq 0x2070
leaq 0x143e(%rip), %rdi      # 0x4558
callq 0x2070
movl %ebx, %edi
callq 0x2210
// File: /workspace/github_c_makefile_star2_O2/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 0x110f(%rip), %xmm0     # 0x4260
movaps %xmm0, (%rdx)
leaq 0x8(%rsp), %rcx
xorl %edi, %edi
callq 0x2230
testl %eax, %eax
jns 0x3187
callq 0x2050
movl (%rax), %edi
leaq 0x11b7(%rip), %rsi      # 0x4329
leaq 0x116f(%rip), %rdx      # 0x42e8
leaq 0x11c0(%rip), %rcx      # 0x4340
xorl %eax, %eax
callq 0x2449
movq 0x8(%rsp), %r14
movq %r14, %rax
movl 0x4(%rax), %edi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2270
movl %eax, %ebx
movq 0x8(%rsp), %rax
testl %ebx, %ebx
js 0x31cf
movq 0x18(%rax), %rsi
movl 0x10(%rax), %edx
movl %ebx, %edi
callq 0x21b0
testl %eax, %eax
je 0x31d4
movl %ebx, %edi
callq 0x2100
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x318f
movq %r14, %rdi
callq 0x2260
leaq 0x40(%rsp), %r14
pushq $0x1
popq %r15
leaq 0x10fc(%rip), %r13      # 0x42e8
leaq 0x114d(%rip), %rbp      # 0x4340
leaq 0x1153(%rip), %r12      # 0x434d
movl $0x578, %edx            # imm = 0x578
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2190
cmpq $0x578, %rax            # imm = 0x578
jne 0x3258
movq 0x2da8(%rip), %rax      # 0x5fc8
movq (%rax), %rcx
movl $0x578, %esi            # imm = 0x578
movq %r14, %rdi
movq %r15, %rdx
callq 0x2220
cmpq $0x578, %rax            # imm = 0x578
je 0x31fa
callq 0x2050
movl (%rax), %edi
leaq 0x1129(%rip), %rsi      # 0x4372
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x2449
jmp 0x31fa
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x2516
jmp 0x31fa
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
pushq $0x61
popq %rdi
callq 0x7106
movq %rax, %rbx
pushq $0x62
popq %rdi
callq 0x7106
xorl %ebp, %ebp
pushq $0x2
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7646
movq 0x14c29(%rip), %rsi     # 0x15fc8
leaq 0x11a(%rip), %rdx       # 0x14c0
leaq 0xbc57(%rip), %rcx      # 0xd004
movq %rax, %rdi
callq 0x72b7
movq %rax, %rbx
leaq 0xbc52(%rip), %rdi      # 0xd011
leaq 0xf0d6(%rip), %rsi      # 0x1049c
movq %rsp, %r15
movq %rax, %rdx
movq %r15, %rcx
callq 0x646d
movl %eax, %r14d
leaq 0xbc6a(%rip), %rsi      # 0xd048
leaq 0xbc31(%rip), %rdx      # 0xd016
pushq $0x12
popq %rcx
movl %eax, %edi
callq 0x4040
movq (%r15), %rax
cmpb $0x61, (%rax)
jne 0x1401
xorl %ebp, %ebp
cmpb $0x0, 0x1(%rax)
sete %bpl
leaq 0xbc22(%rip), %rsi      # 0xd02a
leaq 0xbc07(%rip), %rdx      # 0xd016
pushq $0x13
popq %rcx
movl %ebp, %edi
callq 0x4040
movq (%rsp), %rdi
testl %r14d, %r14d
je 0x1429
callq 0x1270
jmp 0x142e
callq 0x5270
leaq 0xbbdc(%rip), %rdi      # 0xd011
leaq 0xe076(%rip), %rsi      # 0xf4b2
movq %rsp, %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x646d
movl %eax, %ebp
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xbbec(%rip), %rsi      # 0xd047
leaq 0xbbb4(%rip), %r15      # 0xd016
pushq $0x17
popq %rcx
movq %r15, %rdx
callq 0x4040
movq (%r14), %rax
movq 0x30(%rax), %rdi
leaq 0xbb89(%rip), %rsi      # 0xd004
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xbbc1(%rip), %rsi      # 0xd050
pushq $0x18
popq %rcx
movq %r15, %rdx
callq 0x4040
movq (%r14), %rdi
testl %ebp, %ebp
je 0x14a8
callq 0x1270
jmp 0x14ad
callq 0x5270
movq %rbx, %rdi
callq 0x68f0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x61
popq %rdi
callq 0x7106
movq %rax, %rbx
pushq $0x62
popq %rdi
callq 0x7106
xorl %ebp, %ebp
pushq $0x2
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7646
movq 0x14ac1(%rip), %rsi     # 0x15fc8
leaq 0x122(%rip), %rdx       # 0x1630
leaq 0xef87(%rip), %r14      # 0x1049c
leaq 0xbae8(%rip), %r8       # 0xd004
movq %rax, %rdi
movq %r14, %rcx
callq 0x7311
movq %rax, %rbx
leaq 0xbae0(%rip), %rdi      # 0xd011
movq %rsp, %r15
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x646d
movl %eax, %r14d
leaq 0xbafc(%rip), %rsi      # 0xd048
leaq 0xbac3(%rip), %rdx      # 0xd016
pushq $0x24
popq %rcx
movl %eax, %edi
callq 0x4040
movq (%r15), %rdi
testl %r14d, %r14d
je 0x1597
cmpb $0x61, (%rdi)
jne 0x1574
xorl %ebp, %ebp
cmpb $0x0, 0x1(%rdi)
sete %bpl
leaq 0xbaaf(%rip), %rsi      # 0xd02a
leaq 0xba94(%rip), %rdx      # 0xd016
pushq $0x25
popq %rcx
movl %ebp, %edi
callq 0x4040
movq (%rsp), %rdi
callq 0x1270
jmp 0x159c
callq 0x5270
leaq 0xba6e(%rip), %rdi      # 0xd011
leaq 0xdf08(%rip), %rsi      # 0xf4b2
movq %rsp, %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x646d
movl %eax, %ebp
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xba7e(%rip), %rsi      # 0xd047
leaq 0xba46(%rip), %rdx      # 0xd016
pushq $0x29
popq %rcx
callq 0x4040
movq (%r14), %rdi
testl %ebp, %ebp
je 0x15e6
callq 0x1270
jmp 0x161d
movq 0x30(%rdi), %rdi
leaq 0xba13(%rip), %rsi      # 0xd004
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xba4b(%rip), %rsi      # 0xd050
leaq 0xba0a(%rip), %rdx      # 0xd016
pushq $0x2a
popq %rcx
callq 0x4040
movq (%rsp), %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x68f0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
pushq $0x61
popq %rdi
callq 0x7106
movq %rax, %rbx
pushq $0x62
popq %rdi
callq 0x7106
xorl %ebp, %ebp
pushq $0x2
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7646
movq 0x14951(%rip), %rsi     # 0x15fc8
leaq -0x1be(%rip), %rdx      # 0x14c0
leaq 0xb9fb(%rip), %rcx      # 0xd080
leaq 0xee10(%rip), %r14      # 0x1049c
movq %rax, %rdi
movq %r14, %r8
xorl %eax, %eax
callq 0x7379
movq %rax, %rbx
leaq 0xb96e(%rip), %rdi      # 0xd011
movq %rsp, %r15
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x646d
movl %eax, %r14d
leaq 0xb98a(%rip), %rsi      # 0xd048
leaq 0xb951(%rip), %rdx      # 0xd016
pushq $0x36
popq %rcx
movl %eax, %edi
callq 0x4040
movq (%r15), %rax
cmpb $0x61, (%rax)
jne 0x16e1
xorl %ebp, %ebp
cmpb $0x0, 0x1(%rax)
sete %bpl
leaq 0xb942(%rip), %rsi      # 0xd02a
leaq 0xb927(%rip), %rdx      # 0xd016
pushq $0x37
popq %rcx
movl %ebp, %edi
callq 0x4040
movq (%rsp), %rdi
testl %r14d, %r14d
je 0x1709
callq 0x1270
jmp 0x170e
callq 0x5270
leaq 0xb8fc(%rip), %rdi      # 0xd011
leaq 0xdd96(%rip), %rsi      # 0xf4b2
movq %rsp, %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x646d
movl %eax, %ebp
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xb90c(%rip), %rsi      # 0xd047
leaq 0xb8d4(%rip), %r15      # 0xd016
pushq $0x3b
popq %rcx
movq %r15, %rdx
callq 0x4040
movq (%r14), %rax
movq 0x30(%rax), %rdi
leaq 0xb8a9(%rip), %rsi      # 0xd004
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xb8e1(%rip), %rsi      # 0xd050
pushq $0x3c
popq %rcx
movq %r15, %rdx
callq 0x4040
movq (%r14), %rdi
testl %ebp, %ebp
je 0x1788
callq 0x1270
jmp 0x178d
callq 0x5270
movq %rbx, %rdi
callq 0x68f0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x61
popq %rdi
callq 0x7106
movq %rax, %rbx
pushq $0x62
popq %rdi
callq 0x7106
xorl %ebp, %ebp
pushq $0x2
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7646
movq 0x147f5(%rip), %rsi     # 0x15fc8
leaq -0x1aa(%rip), %rdx      # 0x1630
leaq 0xb89f(%rip), %r8       # 0xd080
leaq 0xecb4(%rip), %r14      # 0x1049c
movq %rax, %rdi
movq %r14, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x744b
movq %rax, %rbx
leaq 0xb80f(%rip), %rdi      # 0xd011
movq %rsp, %r15
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x646d
movl %eax, %r14d
leaq 0xb82b(%rip), %rsi      # 0xd048
leaq 0xb7f2(%rip), %rdx      # 0xd016
pushq $0x48
popq %rcx
movl %eax, %edi
callq 0x4040
movq (%r15), %rdi
testl %r14d, %r14d
je 0x1868
cmpb $0x61, (%rdi)
jne 0x1845
xorl %ebp, %ebp
cmpb $0x0, 0x1(%rdi)
sete %bpl
leaq 0xb7de(%rip), %rsi      # 0xd02a
leaq 0xb7c3(%rip), %rdx      # 0xd016
pushq $0x49
popq %rcx
movl %ebp, %edi
callq 0x4040
movq (%rsp), %rdi
callq 0x1270
jmp 0x186d
callq 0x5270
leaq 0xb79d(%rip), %rdi      # 0xd011
leaq 0xdc37(%rip), %rsi      # 0xf4b2
movq %rsp, %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x646d
movl %eax, %ebp
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xb7ad(%rip), %rsi      # 0xd047
leaq 0xb775(%rip), %rdx      # 0xd016
pushq $0x4d
popq %rcx
callq 0x4040
movq (%r14), %rdi
testl %ebp, %ebp
je 0x18b7
callq 0x1270
jmp 0x18ee
movq 0x30(%rdi), %rdi
leaq 0xb742(%rip), %rsi      # 0xd004
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xb77a(%rip), %rsi      # 0xd050
leaq 0xb739(%rip), %rdx      # 0xd016
pushq $0x4e
popq %rcx
callq 0x4040
movq (%rsp), %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x68f0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 -0x59d(%rip), %rdi      # 0x136c
leaq 0xb77e(%rip), %rsi      # 0xd08e
leaq 0xb782(%rip), %rbx      # 0xd099
movq %rbx, %rdx
callq 0x40b7
leaq -0x452(%rip), %rdi      # 0x14d4
leaq 0xb77e(%rip), %rsi      # 0xd0ab
movq %rbx, %rdx
callq 0x40b7
leaq -0x2f8(%rip), %rdi      # 0x1644
leaq 0xb778(%rip), %rsi      # 0xd0bb
movq %rbx, %rdx
callq 0x40b7
leaq -0x1b2(%rip), %rdi      # 0x17a0
leaq 0xb76f(%rip), %rsi      # 0xd0c8
movq %rbx, %rdx
popq %rbx
jmp 0x40b7
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1ece
leaq 0xb25f(%rip), %rcx      # 0xd0dc
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 0x1ece
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rcx), %ecx
addl %ecx, (%rax)
jmp 0x1ece
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rax), %edx
imull (%rcx), %edx
movl %edx, (%rax)
jmp 0x1ece
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rcx), %ecx
subl %ecx, (%rax)
jmp 0x1ece
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_O2/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 0x70ec
leaq 0x5ab7(%rip), %rbx      # 0x79cc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x75a2
leaq 0x6df5(%rip), %rsi      # 0x8d1c
movq %rax, %rdi
callq 0x726b
movq %rax, %r14
movq %rax, 0x10(%rsp)
callq 0x70ec
movq %rbx, %rdi
movq %rax, %rsi
callq 0x75a2
leaq 0x6e10(%rip), %rsi      # 0x8d5e
movq %rax, %rdi
callq 0x726b
movq %rax, %r12
callq 0x70ec
movq %rbx, %rdi
movq %rax, %rsi
callq 0x75a2
leaq 0x6e30(%rip), %rsi      # 0x8da0
movq %rax, %rdi
callq 0x726b
movq %rax, 0x8(%rsp)
leaq 0xb4f8(%rip), %rbx      # 0xd47c
leaq 0xb4f2(%rip), %rdx      # 0xd47d
leaq -0x426(%rip), %rbp      # 0x1b6c
movq 0x1402f(%rip), %r8      # 0x15fc8
leaq -0x423(%rip), %r13      # 0x1b7d
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rcx
movq %r8, %r14
movq %r13, %r9
callq 0x9642
leaq 0xb4d0(%rip), %rsi      # 0xd48b
leaq 0xb182(%rip), %r15      # 0xd144
pushq $0x67
popq %rcx
movl %eax, %edi
movq %r15, %rdx
callq 0x4040
leaq 0xb508(%rip), %rdx      # 0xd4de
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rcx
movq %r14, %r8
movq %r13, %r9
callq 0x9642
leaq 0xb4fa(%rip), %rsi      # 0xd4eb
pushq $0x68
popq %rcx
movl %eax, %edi
movq %r15, %rdx
callq 0x4040
leaq 0xb4da(%rip), %rdx      # 0xd4df
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
leaq 0xb468(%rip), %rsi      # 0xd47c
movq %rbp, %rcx
movq %r14, %r8
movq %r13, %r9
callq 0x9642
leaq 0xb514(%rip), %rsi      # 0xd53d
pushq $0x69
popq %rcx
movl %eax, %edi
movq %r15, %rdx
callq 0x4040
movq 0x10(%rsp), %rdi
callq 0x68f0
movq %r12, %rdi
callq 0x68f0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x68f0
// File: /workspace/github_c_makefile_star2_O2/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 0x7ae4
leaq 0x5957(%rip), %rsi      # 0x79cc
movq 0x13f4c(%rip), %rcx     # 0x15fc8
pushq $0x3
popq %rdi
movq %rax, %rdx
callq 0x75e8
movq %rax, %rbx
leaq 0xaf80(%rip), %r12      # 0xd011
leaq 0xb4f5(%rip), %rbp      # 0xd58d
movq %rsp, %r14
movq %r12, %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x646d
leaq 0xaf95(%rip), %rsi      # 0xd048
leaq 0xb08a(%rip), %r15      # 0xd144
pushq $0x78
popq %rcx
movl %eax, %edi
movq %r15, %rdx
callq 0x4040
movq (%r14), %rdi
movq %rbp, %rsi
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xb4b0(%rip), %r13      # 0xd591
pushq $0x79
popq %rcx
movq %r13, %rsi
movq %r15, %rdx
callq 0x4040
movq (%r14), %rdi
callq 0x1270
leaq 0xb4b2(%rip), %rsi      # 0xd5b0
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x646d
pushq $0x7d
popq %rcx
movl %eax, %edi
leaq 0xaf30(%rip), %rsi      # 0xd048
movq %r15, %rdx
callq 0x4040
movq (%r14), %rdi
movq %rbp, %rsi
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
pushq $0x7e
popq %rcx
movq %r13, %rsi
movq %r15, %rdx
callq 0x4040
movq (%r14), %rdi
callq 0x1270
leaq 0xb466(%rip), %rsi      # 0xd5b6
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x646d
movl %eax, %edi
leaq 0xaee1(%rip), %rsi      # 0xd048
movq %r15, %rdx
movl $0x82, %ecx
callq 0x4040
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 0x4040
movq (%r14), %rdi
callq 0x1270
leaq 0xb416(%rip), %rsi      # 0xd5bc
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x646d
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xae84(%rip), %rsi      # 0xd047
movq %r15, %rdx
movl $0x87, %ecx
callq 0x4040
movq (%r14), %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x68f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xb18e(%rip), %rdi      # 0xd63d
callq 0x837c
leaq 0xf9(%rip), %rsi        # 0x25b4
movq %rax, %rdi
callq 0x726b
leaq 0x5502(%rip), %rdi      # 0x79cc
movq %rax, %rsi
callq 0x75a2
movq %rax, %rbx
andl $0x0, 0x13d08(%rip)     # 0x161e4
leaq 0xb167(%rip), %rdx      # 0xd64a
leaq -0x97e(%rip), %r15      # 0x1b6c
movq 0x13ad7(%rip), %r12     # 0x15fc8
leaq -0x97b(%rip), %r13      # 0x1b7d
movq %rax, %rdi
movq %rdx, %rsi
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x9642
leaq 0xb150(%rip), %rsi      # 0xd663
leaq 0xac2a(%rip), %r14      # 0xd144
movl %eax, %edi
movq %r14, %rdx
movl $0xc5, %ecx
callq 0x4040
xorl %edi, %edi
cmpl $0x6, 0x13cb2(%rip)     # 0x161e4
sete %dil
leaq 0xb193(%rip), %rsi      # 0xd6d0
movq %r14, %rdx
movl $0xc7, %ecx
callq 0x4040
andl $0x0, 0x13c93(%rip)     # 0x161e4
leaq 0xb188(%rip), %rdx      # 0xd6e0
movq %rbx, %rdi
movq %rdx, %rsi
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x9642
leaq 0xb19c(%rip), %rsi      # 0xd70f
movl %eax, %edi
movq %r14, %rdx
movl $0xcd, %ecx
callq 0x4040
xorl %edi, %edi
cmpl $0x7, 0x13c59(%rip)     # 0x161e4
sete %dil
leaq 0xb214(%rip), %rsi      # 0xd7aa
movq %r14, %rdx
movl $0xcf, %ecx
callq 0x4040
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x68f0
// File: /workspace/github_c_makefile_star2_O2/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 0xb1f1(%rip), %rdi      # 0xd7ba
callq 0x837c
movq %rax, %rdi
callq 0x81ef
leaq 0x99(%rip), %rsi        # 0x2676
movq %rax, %rdi
callq 0x726b
leaq 0x53e0(%rip), %rdi      # 0x79cc
movq %rax, %rsi
callq 0x75a2
movq %rax, %rbx
andl $0x0, 0x13bea(%rip)     # 0x161e8
leaq 0xb1d3(%rip), %rsi      # 0xd7d8
leaq 0xb1f8(%rip), %rdx      # 0xd804
leaq -0xaa7(%rip), %rcx      # 0x1b6c
movq 0x139ae(%rip), %r8      # 0x15fc8
leaq -0xaa4(%rip), %r9       # 0x1b7d
movq %rax, %rdi
callq 0x9642
leaq 0xb1ee(%rip), %rsi      # 0xd81e
leaq 0xab0d(%rip), %r14      # 0xd144
movl %eax, %edi
movq %r14, %rdx
movl $0xe7, %ecx
callq 0x4040
xorl %edi, %edi
cmpl $0x9, 0x13b99(%rip)     # 0x161e8
sete %dil
leaq 0xb240(%rip), %rsi      # 0xd89a
movq %r14, %rdx
movl $0xe9, %ecx
callq 0x4040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x68f0
// File: /workspace/github_c_makefile_star2_O2/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 0xb21b(%rip), %rdi      # 0xd8ab
callq 0x837c
movq %rax, %rbx
leaq 0xc446(%rip), %rdx      # 0xeae5
leaq -0xb3a(%rip), %r14      # 0x1b6c
movq 0x1391b(%rip), %r15     # 0x15fc8
leaq -0xb37(%rip), %r12      # 0x1b7d
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0x9642
leaq 0xb1e4(%rip), %rsi      # 0xd8b3
leaq 0xaa6e(%rip), %r13      # 0xd144
movl %eax, %edi
movq %r13, %rdx
movl $0xf3, %ecx
callq 0x4040
leaq 0xd308(%rip), %rdx      # 0xf9f4
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0x9642
leaq 0xb1e7(%rip), %rsi      # 0xd8ee
movl %eax, %edi
movq %r13, %rdx
movl $0xf4, %ecx
callq 0x4040
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x68f0
// File: /workspace/github_c_makefile_star2_O2/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 -0x105c(%rip), %rdi     # 0x1964
leaq 0xb194(%rip), %rsi      # 0xdb5b
leaq 0xb198(%rip), %rbx      # 0xdb66
movq %rbx, %rdx
callq 0x40b7
leaq -0xe4f(%rip), %rdi      # 0x1b8e
leaq 0xb18d(%rip), %rsi      # 0xdb71
movq %rbx, %rdx
callq 0x40b7
leaq -0xaf8(%rip), %rdi      # 0x1efb
leaq 0xb182(%rip), %rsi      # 0xdb7c
movq %rbx, %rdx
callq 0x40b7
leaq -0x9ab(%rip), %rdi      # 0x205e
leaq 0xb177(%rip), %rsi      # 0xdb87
movq %rbx, %rdx
callq 0x40b7
leaq -0x830(%rip), %rdi      # 0x21ef
leaq 0xb16d(%rip), %rsi      # 0xdb93
movq %rbx, %rdx
callq 0x40b7
leaq -0x596(%rip), %rdi      # 0x249f
leaq 0xb161(%rip), %rsi      # 0xdb9d
movq %rbx, %rdx
callq 0x40b7
leaq -0x48d(%rip), %rdi      # 0x25be
leaq 0xb157(%rip), %rsi      # 0xdba9
movq %rbx, %rdx
callq 0x40b7
leaq -0x3e1(%rip), %rdi      # 0x2680
leaq 0xb14d(%rip), %rsi      # 0xdbb5
movq %rbx, %rdx
callq 0x40b7
leaq -0x350(%rip), %rdi      # 0x2727
leaq 0xb140(%rip), %rsi      # 0xdbbe
movq %rbx, %rdx
popq %rbx
jmp 0x40b7
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xad33(%rip), %rdi      # 0xdbce
callq 0x6a1e
movq %rax, %rbx
leaq 0xad2f(%rip), %rdi      # 0xdbd9
callq 0x6a1e
movq %rax, %r14
leaq 0xad28(%rip), %rdi      # 0xdbe1
callq 0x6a1e
movq %rax, %r15
leaq 0xa432(%rip), %rdi      # 0xd2fa
callq 0x6a1e
movq %rax, %r12
leaq 0xb0d0(%rip), %rsi      # 0xdfa7
xorl %edi, %edi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xafa2
pushq $0x4
popq %rdi
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 0x6e12
// File: /workspace/github_c_makefile_star2_O2/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 0xacb2(%rip), %rdi      # 0xdbce
callq 0x6a1e
movq %rax, %rbx
leaq 0xacae(%rip), %rdi      # 0xdbd9
callq 0x6a1e
movq %rax, %r14
leaq 0xaca7(%rip), %rdi      # 0xdbe1
callq 0x6a1e
movq %rax, %r15
leaq 0xa3b1(%rip), %rdi      # 0xd2fa
callq 0x6a1e
movq %rax, %r12
leaq 0xb118(%rip), %rsi      # 0xe070
xorl %edi, %edi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xb076
pushq $0x4
popq %rdi
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 0x6e12
// File: /workspace/github_c_makefile_star2_O2/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 0xaa6d(%rip), %rdi      # 0xe327
callq 0x6a1e
movq %rax, %rbx
leaq 0xb10a(%rip), %rsi      # 0xe9d3
xorl %edi, %edi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xafa2
xorl %edi, %edi
testq %rax, %rax
sete %dil
leaq 0xaae5(%rip), %rsi      # 0xe3cc
leaq 0xa44c(%rip), %r14      # 0xdd3a
movq %r14, %rdx
movl $0x110, %ecx            # imm = 0x110
callq 0x4040
leaq 0xb0f9(%rip), %rdi      # 0xe9fb
leaq 0x9708(%rip), %rsi      # 0xd011
leaq 0x8(%rsp), %r15
movq %rbx, %rdx
movq %r15, %rcx
callq 0x646d
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xb0db(%rip), %rsi      # 0xea03
movq %r14, %rdx
movl $0x114, %ecx            # imm = 0x114
callq 0x4040
xorl %edi, %edi
cmpq $0x0, (%r15)
setne %dil
leaq 0xb0c9(%rip), %rsi      # 0xea0f
movq %r14, %rdx
movl $0x115, %ecx            # imm = 0x115
callq 0x4040
movq (%r15), %rax
movq 0x30(%rax), %rdi
leaq 0xb0be(%rip), %rsi      # 0xea1f
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xb0c4(%rip), %rsi      # 0xea39
movq %r14, %rdx
movl $0x116, %ecx            # imm = 0x116
callq 0x4040
movq (%r15), %rdi
callq 0x5270
pushq $0x1
popq %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6e12
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 -0x14ee(%rip), %rdi     # 0x2a88
leaq 0xaece(%rip), %rsi      # 0xee4b
leaq 0xaed4(%rip), %rbx      # 0xee58
movq %rbx, %rdx
callq 0x40b7
leaq -0x1107(%rip), %rdi     # 0x2e8c
leaq 0xaecc(%rip), %rsi      # 0xee66
movq %rbx, %rdx
callq 0x40b7
leaq -0x109c(%rip), %rdi     # 0x2f0d
leaq 0xaec4(%rip), %rsi      # 0xee74
movq %rbx, %rdx
callq 0x40b7
leaq -0x1031(%rip), %rdi     # 0x2f8e
leaq 0xaec1(%rip), %rsi      # 0xee87
movq %rbx, %rdx
callq 0x40b7
leaq -0xe47(%rip), %rdi      # 0x318e
leaq 0xaeb5(%rip), %rsi      # 0xee91
movq %rbx, %rdx
callq 0x40b7
leaq -0xc5a(%rip), %rdi      # 0x3391
leaq 0xaeac(%rip), %rsi      # 0xee9e
movq %rbx, %rdx
callq 0x40b7
leaq -0x757(%rip), %rdi      # 0x38aa
leaq 0xaea3(%rip), %rsi      # 0xeeab
movq %rbx, %rdx
callq 0x40b7
leaq -0x676(%rip), %rdi      # 0x39a1
leaq 0xae9f(%rip), %rsi      # 0xeebd
movq %rbx, %rdx
callq 0x40b7
leaq -0x3e0(%rip), %rdi      # 0x3c4d
leaq 0xae99(%rip), %rsi      # 0xeecd
movq %rbx, %rdx
popq %rbx
jmp 0x40b7
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x121a9(%rip)           # 0x161f0
movq %rdx, %r8
cmpl $0x0, 0x121a3(%rip)     # 0x161f4
setne %al
testl %edi, %edi
setne %dl
andb %al, %dl
movzbl %dl, %eax
movl %eax, 0x12190(%rip)     # 0x161f4
testl %edi, %edi
je 0x4071
leaq 0x12189(%rip), %rax     # 0x161f8
jmp 0x40b3
movl %ecx, %r9d
movq %rsi, %rcx
movl 0x12983(%rip), %edx     # 0x16a00
incl %edx
leaq 0x1217a(%rip), %rbx     # 0x16200
leaq 0xae5b(%rip), %rsi      # 0xeee8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1220
leaq 0x12972(%rip), %rdi     # 0x16a10
movq %rbx, %rsi
callq 0x1210
incl 0x12954(%rip)           # 0x16a00
leaq 0x1315d(%rip), %rax     # 0x17210
incl (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13148(%rip), %r12     # 0x17214
cmpq $0x800, %r12            # imm = 0x800
je 0x415f
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x10b0
cmpq $0x200, %rax            # imm = 0x200
jae 0x4177
movq %rbx, %rdi
callq 0x10b0
cmpq $0x200, %rax            # imm = 0x200
jae 0x4183
leaq 0x8(%rsp), %rdi
movq %r15, -0x8(%rdi)
movq %r14, %rsi
callq 0x419e
leaq 0x208(%rsp), %rdi
movq %rbx, %rsi
callq 0x419e
imulq $0x408, %r12, %rax      # imm = 0x408
leaq 0x130eb(%rip), %rdi     # 0x17220
addq %rax, %rdi
movq %rsp, %rsi
movl $0x408, %edx            # imm = 0x408
callq 0x1180
leal 0x1(%r12), %eax
movl %eax, 0x130c4(%rip)     # 0x17214
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xada5(%rip), %rdi      # 0xef0b
movl $0x800, %esi            # imm = 0x800
xorl %eax, %eax
callq 0x10d0
callq 0x1040
leaq 0xadb8(%rip), %rdi      # 0xef36
movq %r14, %rsi
jmp 0x418d
leaq 0xade7(%rip), %rdi      # 0xef71
movq %rbx, %rsi
movl $0x200, %edx            # imm = 0x200
xorl %eax, %eax
callq 0x10d0
callq 0x1040