LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_utils.c
// Function: ringbuffer_create
struct ringbuffer *ringbuffer_create(unsigned int size)
{
	struct ringbuffer *rb;

	/* Size needs to be of power of 2 */
	if ((size & (size - 1)) != 0)
		return NULL;

	rb = calloc(1, sizeof(*rb));
	if (!rb)
		return NULL;

	rb->size = size;
	rb->data = calloc(rb->size, sizeof(struct ringbuffer_sample));

	return rb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x23a5
movq $0x0, -0x8(%rbp)
jmp 0x23f7
movl $0x1, %edi
movl $0x18, %esi
callq 0x2130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x23c9
movq $0x0, -0x8(%rbp)
jmp 0x23f7
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
movl $0x18, %esi
callq 0x2130
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_utils.c
// Function: ringbuffer_write
int ringbuffer_write(struct ringbuffer *rb, struct timespec ts, uint64_t val)
{
	uint32_t read, idx;

	read = READ_ONCE(rb->read);
	if (ringbuffer_full(rb->size, read, rb->write)) {
		rb->overflow++;
		return 1;
	}

	idx = ringbuffer_mask(rb->size, rb->write + 1);
	rb->data[idx].ts = ts;
	rb->data[idx].val = val;

	WRITE_ONCE(rb->write, rb->write + 1);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl 0x1c66(%rip), %eax      # 0x40c4
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl -0x2c(%rbp), %esi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x2530
cmpl $0x0, %eax
je 0x24a7
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x251e
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %esi
addl $0x1, %esi
callq 0x2550
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x30(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x30(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_utils.c
// Function: ringbuffer_read
int ringbuffer_read(struct ringbuffer *rb, struct timespec *ts, uint64_t *val)
{
	uint32_t write, idx;

	write = READ_ONCE(rb->write);
	if (ringbuffer_empty(rb->read, write))
		return 1;

	idx = ringbuffer_mask(rb->size, rb->read + 1);
	*ts = rb->data[idx].ts;
	*val = rb->data[idx].val;

	WRITE_ONCE(rb->read, rb->read + 1);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl 0x1b3a(%rip), %eax      # 0x40c4
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
movl -0x24(%rbp), %esi
callq 0x2650
cmpl $0x0, %eax
je 0x25c0
movl $0x1, -0x4(%rbp)
jmp 0x263d
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
addl $0x1, %esi
callq 0x2550
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x28(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x28(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_utils.c
// Function: err_handler
void _err_handler(int error, char *fmt, ...)
{
	va_list ap;
	char *msg;

	va_start(ap, fmt);
	vasprintf(&msg, fmt, ap);
	va_end(ap);

	fprintf(stderr, "%s: %s\n", msg, strerror(error));

	free(msg);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x26ab
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x2090
leaq -0x30(%rbp), %rax
movq 0x38ea(%rip), %rax      # 0x5ff8
movq (%rax), %rax
movq %rax, -0x100(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xf8(%rbp)
movl -0x4(%rbp), %edi
callq 0x2250
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rdx
movq %rax, %rcx
leaq 0x1985(%rip), %rsi      # 0x40c8
movb $0x0, %al
callq 0x2150
movq -0x38(%rbp), %rdi
callq 0x2030
movl $0x1, %edi
callq 0x2210
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_utils.c
// Function: parse_num
long int parse_num(const char *str, int base, size_t *len)
{
	long int ret;
	char *endptr;

	errno = 0;
	ret = strtol(str, &endptr, base);
	if (errno)
		return -errno;
	if (ret < 0)
		return -ERANGE;

	if (len)
		*len = endptr - str;

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x2040
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x30(%rbp), %rsi
callq 0x2170
movq %rax, -0x28(%rbp)
callq 0x2040
cmpl $0x0, (%rax)
je 0x2850
callq 0x2040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x2882
cmpq $0x0, -0x28(%rbp)
jge 0x2861
movq $-0x22, -0x8(%rbp)
jmp 0x2882
cmpq $0x0, -0x20(%rbp)
je 0x287a
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_utils.c
// Function: parse_time
long int parse_time(const char *str)
{
	long int t;
	char *end;

	t = strtol(str, &end, 10);

	if (!(strlen(end) == 0 || strlen(end) == 1))
		return -EINVAL;

	if (end) {
		switch (*end) {
		case 's':
		case 'S':
			break;
		case 'm':
		case 'M':
			t *= 60;
			break;

		case 'h':
		case 'H':
			t *= 60 * 60;
			break;

		case 'd':
		case 'D':
			t *= 24 * 60 * 60;
			break;
		default:
			return -EINVAL;
		}
	}

	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0xa, %edx
callq 0x2170
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20c0
cmpq $0x0, %rax
je 0x28da
movq -0x20(%rbp), %rdi
callq 0x20c0
cmpq $0x1, %rax
je 0x28da
movq $-0x16, -0x8(%rbp)
jmp 0x2947
cmpq $0x0, -0x20(%rbp)
je 0x293f
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
addl $-0x44, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x2f, %eax
ja 0x2933
movq -0x28(%rbp), %rax
leaq 0x1703(%rip), %rcx      # 0x4004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x293d
imulq $0x3c, -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x293d
imulq $0xe10, -0x18(%rbp), %rax # imm = 0xE10
movq %rax, -0x18(%rbp)
jmp 0x293d
imulq $0x15180, -0x18(%rbp), %rax # imm = 0x15180
movq %rax, -0x18(%rbp)
jmp 0x293d
movq $-0x16, -0x8(%rbp)
jmp 0x2947
jmp 0x293f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_utils.c
// Function: cpuset_fprint
void cpuset_fprint(FILE *f, cpu_set_t *set)
{
	unsigned long bit = 0, range = 0;
	unsigned long i, t, comma = 0;

	for (i = 0, t = 0; t < (unsigned) CPU_COUNT(set); t += bit, i++) {
		bit = CPU_ISSET(i, set);
		if (!range && bit) {
			if (comma)
				fputc(',', f);

			comma = 1;
			fprintf(f, "%lu", i);
		} else if (!bit) {
			_cpuset_fprint_end(f, i, range);
			range = 0;
		}
		range += bit;
	}

	_cpuset_fprint_end(f, i, range);
	fprintf(f, " = %u [0x%lX]", CPU_COUNT(set), cpuset_to_bits(set));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
movl $0x80, %edi
callq 0x20b0
movl %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x2ab1
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shrq $0x3, %rax
cmpq $0x80, %rax
jae 0x2a0e
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x40(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x54(%rbp)
jmp 0x2a15
xorl %eax, %eax
movl %eax, -0x54(%rbp)
jmp 0x2a15
movl -0x54(%rbp), %eax
movl %eax, -0x44(%rbp)
movslq -0x44(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2a66
cmpq $0x0, -0x18(%rbp)
je 0x2a66
cmpq $0x0, -0x38(%rbp)
je 0x2a46
movq -0x8(%rbp), %rsi
movl $0x2c, %edi
callq 0x2110
movq $0x1, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1768(%rip), %rsi      # 0x41c5
movb $0x0, %al
callq 0x2150
jmp 0x2a88
cmpq $0x0, -0x18(%rbp)
jne 0x2a86
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2b10
movq $0x0, -0x20(%rbp)
jmp 0x2a88
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2998
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2b10
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
movl $0x80, %edi
callq 0x20b0
movl %eax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b60
movq -0x60(%rbp), %rdi
movl -0x58(%rbp), %edx
movq %rax, %rcx
leaq 0x15db(%rip), %rsi      # 0x40d0
movb $0x0, %al
callq 0x2150
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_utils.c
// Function: cpuset_to_bits
static unsigned long cpuset_to_bits(cpu_set_t *set)
{
	unsigned long bits = 0;
	unsigned int i, t, bit;

	for (i = 0, t = 0; t < (unsigned) CPU_COUNT(set); i++) {
		bit = CPU_ISSET(i, set);
		bits |= bit << i;
		t += bit;
	}

	return bits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movl $0x80, %edi
callq 0x20b0
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jae 0x2c2d
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shrq $0x3, %rax
cmpq $0x80, %rax
jae 0x2bf1
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
jmp 0x2bf8
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x2bf8
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %cl, %eax
movl %eax, %eax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b82
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x2800
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x2e86
jmp 0x2e60
movq 0x3191(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1354(%rip), %rsi      # 0x41c9
movb $0x0, %al
callq 0x2150
movl $0x1, %edi
callq 0x2210
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_utils.c
// Function: cpuset_from_bits
static void cpuset_from_bits(cpu_set_t *set, unsigned long bits)
{
	unsigned i;

	for (i = 0; i < sizeof(bits) * 8; i++)
		if ((1UL << i) & bits)
			CPU_SET(i, set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x40, %rax
jae 0x2f21
movl -0x14(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x2f14
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x3, %rax
cmpq $0x80, %rax
jae 0x2f04
movq -0x20(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rdx
shrq $0x6, %rdx
orq (%rcx,%rdx,8), %rax
movq %rax, (%rcx,%rdx,8)
movq %rax, -0x30(%rbp)
jmp 0x2f0c
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x2f0c
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x2f16
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2ea3
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x21c0
cltq
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x30(%rbp)
movb %al, -0x39(%rbp)
jne 0x2f6d
callq 0x2040
cmpl $0x4, (%rax)
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x2f40
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x2f9d
callq 0x2040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x3033
movl $0x1e, %edi
callq 0x21f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2180
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2fd1
movl $0xfffffff4, -0x20(%rbp) # imm = 0xFFFFFFF4
jmp 0x3025
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
subq $0x1, %rdx
callq 0x2120
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x3002
callq 0x2040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x20(%rbp)
jmp 0x3011
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0x20(%rbp)
jge 0x3023
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
jmp 0x3025
movl -0x1c(%rbp), %edi
callq 0x2100
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2240
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3087
jmp 0x3062
callq 0x2040
movl (%rax), %edi
leaq 0x10c4(%rip), %rsi      # 0x4134
leaq 0x10a5(%rip), %rdx      # 0x411c
leaq 0x10c8(%rip), %rcx      # 0x4146
movb $0x0, %al
callq 0x2670
jmp 0x3087
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3040
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2160
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq -0x28(%rbp), %rdi
leaq 0x106c(%rip), %rsi      # 0x4150
movb $0x0, %al
callq 0x21a0
cmpl $0x0, %eax
jge 0x3117
jmp 0x30f2
callq 0x2040
movl (%rax), %edi
leaq 0x1056(%rip), %rsi      # 0x4156
leaq 0x1015(%rip), %rdx      # 0x411c
leaq 0x105c(%rip), %rcx      # 0x416a
movb $0x0, %al
callq 0x2670
jmp 0x3117
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x21d0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2030
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1005(%rip), %rsi      # 0x4173
callq 0x21d0
movq %rax, -0x2018(%rbp)
cmpq $0x0, -0x2018(%rbp)
jne 0x31ab
jmp 0x3186
movq -0x8(%rbp), %rcx
leaq 0xfe4(%rip), %rdi       # 0x4175
leaq 0xf84(%rip), %rsi       # 0x411c
leaq 0x1000(%rip), %rdx      # 0x419f
movb $0x0, %al
callq 0x2760
jmp 0x3295
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x11b5(%rip), %rdx      # 0x436f
callq 0x30a0
movq %rax, -0x2020(%rbp)
cmpq $0x0, -0x2020(%rbp)
jne 0x3201
movq -0x2020(%rbp), %rdi
callq 0x20a0
movq -0x8(%rbp), %rcx
leaq 0xfbe(%rip), %rdi       # 0x41a5
leaq 0xf2e(%rip), %rsi       # 0x411c
leaq 0xfaa(%rip), %rdx       # 0x419f
movb $0x0, %al
callq 0x2760
jmp 0x3295
jmp 0x3203
leaq -0x2010(%rbp), %rdi
movq -0x2018(%rbp), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x2080
movq %rax, -0x2028(%rbp)
cmpq $0x0, %rax
jbe 0x327b
leaq -0x2010(%rbp), %rdi
movq -0x2028(%rbp), %rdx
movq -0x2020(%rbp), %rcx
movl $0x1, %esi
callq 0x2220
cmpq -0x2028(%rbp), %rax
je 0x3279
jmp 0x3257
movq -0x8(%rbp), %rcx
leaq 0xf43(%rip), %rdi       # 0x41a5
leaq 0xeb3(%rip), %rsi       # 0x411c
leaq 0xf2f(%rip), %rdx       # 0x419f
movb $0x0, %al
callq 0x2760
jmp 0x327d
jmp 0x3203
jmp 0x327d
movq -0x2020(%rbp), %rdi
callq 0x20a0
movq -0x2018(%rbp), %rdi
callq 0x20a0
addq $0x2030, %rsp           # imm = 0x2030
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xf4e(%rip), %rsi       # 0x420c
leaq 0x10aa(%rip), %rdx      # 0x436f
callq 0x30a0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3303
jmp 0x32d7
callq 0x2040
movl (%rax), %edi
movq -0x8(%rbp), %rax
movq (%rax), %r8
leaq 0xf2c(%rip), %rsi       # 0x4218
leaq 0xf5a(%rip), %rdx       # 0x424d
leaq 0xf64(%rip), %rcx       # 0x425e
movb $0x0, %al
callq 0x2670
jmp 0x3303
jmp 0x3305
movq -0x10(%rbp), %rcx
leaq -0x2c(%rbp), %rdi
movl $0x1c, %esi
movl $0x1, %edx
callq 0x2080
cmpq $0x0, %rax
je 0x3345
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x18(%rbp), %r9
leaq 0xf2d(%rip), %rsi       # 0x4269
movb $0x0, %al
callq 0x2150
jmp 0x3305
movq -0x38(%rbp), %rdi
callq 0x20a0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x33d3
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x33dc
jmp 0x33ec
jmp 0x33de
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x33b8
cmpq $0x0, -0x18(%rbp)
jne 0x3417
jmp 0x33f5
movq 0x2bfc(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0xe76(%rip), %rsi       # 0x427c
movb $0x0, %al
callq 0x2150
movl $0x1, %edi
callq 0x2210
movl $0x10, %edi
callq 0x2180
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x345b
jmp 0x3439
movq 0x2bb8(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0xe4f(%rip), %rsi       # 0x4299
movb $0x0, %al
callq 0x2150
movl $0x1, %edi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x20f0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_plugin.c
// Function: jd_slist_remove
void jd_slist_remove(struct jd_slist *jd_slist, void *data)
{
	struct jd_slist *last, *l;

	last = jd_slist;
	l = last->next;
	while (l && l->data != data) {
		last = l;
		l = l->next;
	}

	if (!l) {
		warn_handler("Element not found to remove");
		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x34d1
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x34da
jmp 0x34f0
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x34b4
cmpq $0x0, -0x20(%rbp)
jne 0x3517
jmp 0x34f9
leaq 0xdba(%rip), %rdi       # 0x42ba
leaq 0xdd9(%rip), %rsi       # 0x42e0
leaq 0xdde(%rip), %rdx       # 0x42ec
movb $0x0, %al
callq 0x2760
jmp 0x3517
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x2c46(%rip), %rax      # 0x6180
cmpq $0x0, (%rax,%rcx,8)
je 0x3598
movslq -0x4(%rbp), %rcx
leaq 0x2c34(%rip), %rax      # 0x6180
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
callq *0x8(%rax)
cmpl $0x0, %eax
je 0x358b
jmp 0x3562
movq 0x2a8f(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xd82(%rip), %rsi       # 0x42fc
movb $0x0, %al
callq 0x2150
movl $0x1, %edi
callq 0x2210
jmp 0x358d
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x352f
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_plugin.c
// Function: _jd_plugin_cleanup
void __jd_plugin_cleanup(void)
{
	int i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x2bc6(%rip), %rax      # 0x6180
cmpq $0x0, (%rax,%rcx,8)
je 0x35e6
movslq -0x4(%rbp), %rcx
leaq 0x2bb4(%rip), %rax      # 0x6180
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
callq *0x10(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x35af
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0xb2a(%rip), %rdi       # 0x43ec
movb $0x0, %al
callq 0x20e0
leaq 0xb3b(%rip), %rdi       # 0x440b
movb $0x0, %al
callq 0x20e0
leaq 0xc7c(%rip), %rdi       # 0x455a
movb $0x0, %al
callq 0x20e0
leaq 0xb57(%rip), %rdi       # 0x4443
movb $0x0, %al
callq 0x20e0
leaq 0xb51(%rip), %rdi       # 0x444b
movb $0x0, %al
callq 0x20e0
leaq 0xb62(%rip), %rdi       # 0x446a
movb $0x0, %al
callq 0x20e0
leaq 0xb85(%rip), %rdi       # 0x449b
movb $0x0, %al
callq 0x20e0
leaq 0xbb3(%rip), %rdi       # 0x44d7
movb $0x0, %al
callq 0x20e0
movl -0x4(%rbp), %edi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jittersamples.c
// Function: read_online_cpus
static void read_online_cpus(struct jd_samples_info *info)
{
	FILE *fd;
	int n;

	fd = jd_fopen(info->dir, "cpus_online", "r");
	if (!fd)
		err_handler(errno, "Could not read %s/cpus_online\n", info->dir);
	n = fscanf(fd, "%d\n", &info->cpus_online);
	if (n == EOF) {
		if (ferror(fd)) {
			err_handler(errno, "fscanf()");
			perror("fscanf");
		} else {
			fprintf(stderr, "cpus_online: No matching characters, no matching failure\n");
			exit(1);
		}
	} else if (n != 1) {
		fprintf(stderr, "fscan() read more then one element\n");
		exit(1);
	}
	fclose(fd);

	if (info->cpus_online < 1) {
		fprintf(stderr, "invalid input from cpus_online\n");
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xa24(%rip), %rsi       # 0x456e
leaq 0x622(%rip), %rdx       # 0x4173
callq 0x30a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3b8f
jmp 0x3b63
callq 0x2040
movl (%rax), %edi
movq -0x8(%rbp), %rax
movq (%rax), %r8
leaq 0xa02(%rip), %rsi       # 0x457a
leaq 0x827(%rip), %rdx       # 0x43a6
leaq 0xa1c(%rip), %rcx       # 0x45a2
movb $0x0, %al
callq 0x2670
jmp 0x3b8f
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0x8, %rdx
leaq 0xa11(%rip), %rsi       # 0x45b3
movb $0x0, %al
callq 0x2060
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x3c17
movq -0x10(%rbp), %rdi
callq 0x2070
cmpl $0x0, %eax
je 0x3bf3
jmp 0x3bc2
callq 0x2040
movl (%rax), %edi
leaq 0x9e7(%rip), %rsi       # 0x45b7
leaq 0x7cf(%rip), %rdx       # 0x43a6
leaq 0x9c4(%rip), %rcx       # 0x45a2
movb $0x0, %al
callq 0x2670
leaq 0x9dd(%rip), %rdi       # 0x45c9
callq 0x21e0
jmp 0x3c15
movq 0x23fe(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x9cc(%rip), %rsi       # 0x45d0
movb $0x0, %al
callq 0x2150
movl $0x1, %edi
callq 0x2210
jmp 0x3c41
cmpl $0x1, -0x14(%rbp)
je 0x3c3f
movq 0x23d4(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x9dc(%rip), %rsi       # 0x460a
movb $0x0, %al
callq 0x2150
movl $0x1, %edi
callq 0x2210
jmp 0x3c41
movq -0x10(%rbp), %rdi
callq 0x20a0
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jae 0x3c76
movq 0x239d(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x9c9(%rip), %rsi       # 0x462e
movb $0x0, %al
callq 0x2150
movl $0x1, %edi
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x61, %edi
callq 0x9f20
movq %rax, -0x20(%rbp)
movl $0x62, %edi
callq 0x9f20
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
movb $0x0, %al
callq 0xa7b0
movq %rax, %rdi
movq 0x19c4b(%rip), %rsi     # 0x1bfc8
leaq 0x13c(%rip), %rdx       # 0x24c0
leaq 0x11c79(%rip), %rcx     # 0x14004
callq 0xa220
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x11c72(%rip), %rdi     # 0x14011
leaq 0x1524e(%rip), %rsi     # 0x175f4
leaq -0x10(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq 0x11c8c(%rip), %rsi     # 0x14048
leaq 0x11c53(%rip), %rdx     # 0x14016
movl $0x12, %ecx
callq 0x5780
movq -0x10(%rbp), %rdi
leaq 0x1521c(%rip), %rsi     # 0x175f4
callq 0x2110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x11c3b(%rip), %rsi     # 0x1402a
leaq 0x11c20(%rip), %rdx     # 0x14016
movl $0x13, %ecx
callq 0x5780
cmpl $0x0, -0x4(%rbp)
je 0x2411
movq -0x10(%rbp), %rdi
callq 0x2240
jmp 0x241a
movq -0x10(%rbp), %rdi
callq 0x6ed0
movq -0x18(%rbp), %rdx
leaq 0x11bec(%rip), %rdi     # 0x14011
leaq 0x14042(%rip), %rsi     # 0x1646e
leaq -0x10(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x11bfa(%rip), %rsi     # 0x14047
leaq 0x11bc2(%rip), %rdx     # 0x14016
movl $0x17, %ecx
callq 0x5780
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
leaq 0x11b97(%rip), %rsi     # 0x14004
callq 0x2110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x11bcc(%rip), %rsi     # 0x14050
leaq 0x11b8b(%rip), %rdx     # 0x14016
movl $0x18, %ecx
callq 0x5780
cmpl $0x0, -0x4(%rbp)
je 0x24a6
movq -0x10(%rbp), %rdi
callq 0x2240
jmp 0x24af
movq -0x10(%rbp), %rdi
callq 0x6ed0
movq -0x18(%rbp), %rdi
callq 0x9160
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x61, %edi
callq 0x9f20
movq %rax, -0x20(%rbp)
movl $0x62, %edi
callq 0x9f20
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
movb $0x0, %al
callq 0xa7b0
movq %rax, %rdi
movq 0x19a9b(%rip), %rsi     # 0x1bfc8
leaq 0x15c(%rip), %rdx       # 0x2690
leaq 0x150b9(%rip), %rcx     # 0x175f4
leaq 0x11ac2(%rip), %r8      # 0x14004
callq 0xa2b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x11abb(%rip), %rdi     # 0x14011
leaq 0x15097(%rip), %rsi     # 0x175f4
leaq -0x10(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq 0x11ad5(%rip), %rsi     # 0x14048
leaq 0x11a9c(%rip), %rdx     # 0x14016
movl $0x24, %ecx
callq 0x5780
cmpl $0x0, -0x4(%rbp)
je 0x25bd
movq -0x10(%rbp), %rdi
leaq 0x1505f(%rip), %rsi     # 0x175f4
callq 0x2110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x11a7e(%rip), %rsi     # 0x1402a
leaq 0x11a63(%rip), %rdx     # 0x14016
movl $0x25, %ecx
callq 0x5780
cmpl $0x0, -0x4(%rbp)
je 0x25ce
movq -0x10(%rbp), %rdi
callq 0x2240
jmp 0x25d7
movq -0x10(%rbp), %rdi
callq 0x6ed0
movq -0x18(%rbp), %rdx
leaq 0x11a2f(%rip), %rdi     # 0x14011
leaq 0x13e85(%rip), %rsi     # 0x1646e
leaq -0x10(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x11a3d(%rip), %rsi     # 0x14047
leaq 0x11a05(%rip), %rdx     # 0x14016
movl $0x29, %ecx
callq 0x5780
cmpl $0x0, -0x4(%rbp)
jne 0x2658
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
leaq 0x119d4(%rip), %rsi     # 0x14004
callq 0x2110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x11a09(%rip), %rsi     # 0x14050
leaq 0x119c8(%rip), %rdx     # 0x14016
movl $0x2a, %ecx
callq 0x5780
cmpl $0x0, -0x4(%rbp)
je 0x2669
movq -0x10(%rbp), %rdi
callq 0x2240
jmp 0x2672
movq -0x10(%rbp), %rdi
callq 0x6ed0
movq -0x18(%rbp), %rdi
callq 0x9160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x61, %edi
callq 0x9f20
movq %rax, -0x20(%rbp)
movl $0x62, %edi
callq 0x9f20
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
movb $0x0, %al
callq 0xa7b0
movq %rax, %rdi
movq 0x198bb(%rip), %rsi     # 0x1bfc8
leaq -0x254(%rip), %rdx      # 0x24c0
leaq 0x11965(%rip), %rcx     # 0x14080
leaq 0x14ed2(%rip), %r8      # 0x175f4
movb $0x0, %al
callq 0xa350
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x118d9(%rip), %rdi     # 0x14011
leaq 0x14eb5(%rip), %rsi     # 0x175f4
leaq -0x10(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq 0x118f3(%rip), %rsi     # 0x14048
leaq 0x118ba(%rip), %rdx     # 0x14016
movl $0x36, %ecx
callq 0x5780
movq -0x10(%rbp), %rdi
leaq 0x14e83(%rip), %rsi     # 0x175f4
callq 0x2110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x118a2(%rip), %rsi     # 0x1402a
leaq 0x11887(%rip), %rdx     # 0x14016
movl $0x37, %ecx
callq 0x5780
cmpl $0x0, -0x4(%rbp)
je 0x27aa
movq -0x10(%rbp), %rdi
callq 0x2240
jmp 0x27b3
movq -0x10(%rbp), %rdi
callq 0x6ed0
movq -0x18(%rbp), %rdx
leaq 0x11853(%rip), %rdi     # 0x14011
leaq 0x13ca9(%rip), %rsi     # 0x1646e
leaq -0x10(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x11861(%rip), %rsi     # 0x14047
leaq 0x11829(%rip), %rdx     # 0x14016
movl $0x3b, %ecx
callq 0x5780
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
leaq 0x117fe(%rip), %rsi     # 0x14004
callq 0x2110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x11833(%rip), %rsi     # 0x14050
leaq 0x117f2(%rip), %rdx     # 0x14016
movl $0x3c, %ecx
callq 0x5780
cmpl $0x0, -0x4(%rbp)
je 0x283f
movq -0x10(%rbp), %rdi
callq 0x2240
jmp 0x2848
movq -0x10(%rbp), %rdi
callq 0x6ed0
movq -0x18(%rbp), %rdi
callq 0x9160
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x61, %edi
callq 0x9f20
movq %rax, -0x20(%rbp)
movl $0x62, %edi
callq 0x9f20
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
movb $0x0, %al
callq 0xa7b0
movq %rax, %rdi
movq 0x1972b(%rip), %rsi     # 0x1bfc8
leaq -0x214(%rip), %rdx      # 0x2690
leaq 0x14d49(%rip), %r9      # 0x175f4
leaq 0x117ce(%rip), %r8      # 0x14080
movq %r9, %rcx
movb $0x0, %al
callq 0xa420
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x11746(%rip), %rdi     # 0x14011
leaq 0x14d22(%rip), %rsi     # 0x175f4
leaq -0x10(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq 0x11760(%rip), %rsi     # 0x14048
leaq 0x11727(%rip), %rdx     # 0x14016
movl $0x48, %ecx
callq 0x5780
cmpl $0x0, -0x4(%rbp)
je 0x2932
movq -0x10(%rbp), %rdi
leaq 0x14cea(%rip), %rsi     # 0x175f4
callq 0x2110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x11709(%rip), %rsi     # 0x1402a
leaq 0x116ee(%rip), %rdx     # 0x14016
movl $0x49, %ecx
callq 0x5780
cmpl $0x0, -0x4(%rbp)
je 0x2943
movq -0x10(%rbp), %rdi
callq 0x2240
jmp 0x294c
movq -0x10(%rbp), %rdi
callq 0x6ed0
movq -0x18(%rbp), %rdx
leaq 0x116ba(%rip), %rdi     # 0x14011
leaq 0x13b10(%rip), %rsi     # 0x1646e
leaq -0x10(%rbp), %rcx
callq 0x88a0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x116c8(%rip), %rsi     # 0x14047
leaq 0x11690(%rip), %rdx     # 0x14016
movl $0x4d, %ecx
callq 0x5780
cmpl $0x0, -0x4(%rbp)
jne 0x29cd
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
leaq 0x1165f(%rip), %rsi     # 0x14004
callq 0x2110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x11694(%rip), %rsi     # 0x14050
leaq 0x11653(%rip), %rdx     # 0x14016
movl $0x4e, %ecx
callq 0x5780
cmpl $0x0, -0x4(%rbp)
je 0x29de
movq -0x10(%rbp), %rdi
callq 0x2240
jmp 0x29e7
movq -0x10(%rbp), %rdi
callq 0x6ed0
movq -0x18(%rbp), %rdi
callq 0x9160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq -0x6cb(%rip), %rdi      # 0x2340
leaq 0x1167c(%rip), %rsi     # 0x1408e
leaq 0x11680(%rip), %rdx     # 0x14099
callq 0x5850
leaq -0x535(%rip), %rdi      # 0x24f0
leaq 0x1167f(%rip), %rsi     # 0x140ab
leaq 0x11666(%rip), %rdx     # 0x14099
callq 0x5850
leaq -0x36f(%rip), %rdi      # 0x26d0
leaq 0x11675(%rip), %rsi     # 0x140bb
leaq 0x1164c(%rip), %rdx     # 0x14099
callq 0x5850
leaq -0x1f9(%rip), %rdi      # 0x2860
leaq 0x11668(%rip), %rsi     # 0x140c8
leaq 0x11632(%rip), %rdx     # 0x14099
callq 0x5850
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
addl $-0x25, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xa, %eax
ja 0x3196
movq -0x20(%rbp), %rax
leaq 0x10fdd(%rip), %rcx     # 0x140dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
imull (%rax), %ecx
movl %ecx, (%rax)
jmp 0x3198
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x3198
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
cltd
idivl %ecx
movq -0x30(%rbp), %rax
movl %edx, (%rax)
jmp 0x3198
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x3198
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
jmp 0x3198
jmp 0x3198
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x9ef0
movq %rax, %rsi
leaq 0x7b29(%rip), %rdi      # 0xad60
callq 0xa650
movq %rax, %rdi
leaq 0x971a(%rip), %rsi      # 0xc960
callq 0xa170
movq %rax, -0x8(%rbp)
callq 0x9ef0
movq %rax, %rsi
leaq 0x7b02(%rip), %rdi      # 0xad60
callq 0xa650
movq %rax, %rdi
leaq 0x9763(%rip), %rsi      # 0xc9d0
callq 0xa170
movq %rax, -0x10(%rbp)
callq 0x9ef0
movq %rax, %rsi
leaq 0x7adb(%rip), %rdi      # 0xad60
callq 0xa650
movq %rax, %rdi
leaq 0x97cc(%rip), %rsi      # 0xca60
callq 0xa170
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x111d4(%rip), %rsi     # 0x1447c
leaq 0x111ce(%rip), %rdx     # 0x1447d
leaq -0x5b6(%rip), %rcx      # 0x2d00
movq 0x18d0b(%rip), %r8      # 0x1bfc8
leaq -0x594(%rip), %r9       # 0x2d30
callq 0xd780
movl %eax, %edi
leaq 0x111b9(%rip), %rsi     # 0x1448b
leaq 0x10e6b(%rip), %rdx     # 0x14144
movl $0x67, %ecx
callq 0x5780
movq -0x10(%rbp), %rdi
leaq 0x1118e(%rip), %rsi     # 0x1447c
leaq 0x111e9(%rip), %rdx     # 0x144de
leaq -0x5fc(%rip), %rcx      # 0x2d00
movq 0x18cc5(%rip), %r8      # 0x1bfc8
leaq -0x5da(%rip), %r9       # 0x2d30
callq 0xd780
movl %eax, %edi
leaq 0x111d3(%rip), %rsi     # 0x144eb
leaq 0x10e25(%rip), %rdx     # 0x14144
movl $0x68, %ecx
callq 0x5780
movq -0x18(%rbp), %rdi
leaq 0x11148(%rip), %rsi     # 0x1447c
leaq 0x111a4(%rip), %rdx     # 0x144df
leaq -0x642(%rip), %rcx      # 0x2d00
movq 0x18c7f(%rip), %r8      # 0x1bfc8
leaq -0x620(%rip), %r9       # 0x2d30
callq 0xd780
movl %eax, %edi
leaq 0x111df(%rip), %rsi     # 0x1453d
leaq 0x10ddf(%rip), %rdx     # 0x14144
movl $0x69, %ecx
callq 0x5780
movq -0x8(%rbp), %rdi
callq 0x9160
movq -0x10(%rbp), %rdi
callq 0x9160
movq -0x18(%rbp), %rdi
callq 0x9160
addq $0x20, %rsp
popq %rbp
retq