LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/vrancurel[P]ec/mat.c
// Function: mat_swap_cols
void mat_swap_cols(t_mat *mat, int c1, int c2)
{
  int i;

  assert(c1 < mat->n_cols && c2 < mat->n_cols);
  for (i = 0;i < mat->n_rows;i++) {
    int val = MAT_ITEM(mat, i, c1);
    MAT_ITEM(mat, i, c1) = MAT_ITEM(mat, i, c2);
    MAT_ITEM(mat, i, c2) = val;
  }
}

// Assembly:
pushq %rax
movl 0x4(%rdi), %eax
cmpl %esi, %eax
jbe 0x26be
cmpl %edx, %eax
jbe 0x26be
cmpl $0x0, (%rdi)
je 0x26bc
movq 0x8(%rdi), %rax
xorl %ecx, %ecx
movl 0x4(%rdi), %r8d
imull %ecx, %r8d
leal (%r8,%rsi), %r9d
movl (%rax,%r9,4), %r10d
addl %edx, %r8d
movl (%rax,%r8,4), %r8d
movl %r8d, (%rax,%r9,4)
movl 0x4(%rdi), %r8d
imull %ecx, %r8d
addl %edx, %r8d
movl %r10d, (%rax,%r8,4)
incl %ecx
cmpl (%rdi), %ecx
jb 0x268c
popq %rax
retq
leaq 0xc46(%rip), %rdi       # 0x330b
leaq 0xc64(%rip), %rsi       # 0x3330
leaq 0xc63(%rip), %rcx       # 0x3336
movl $0x63, %edx
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/vrancurel[P]ec/mat.c
// Function: mat_transform1
void mat_transform1(t_mat *tmp, int i)
{
  int k;
  int f_minus_1 = gdiv(1, MAT_ITEM(tmp, i, i));

  for (k = 0;k < tmp->n_rows;k++) {
    MAT_ITEM(tmp, k, i) = gmul(f_minus_1, MAT_ITEM(tmp, k, i));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movl 0x4(%rdi), %ecx
incl %ecx
imull %esi, %ecx
movl (%rax,%rcx,4), %esi
movl $0x1, %edi
callq 0x14ac
cmpl $0x0, (%r14)
je 0x273e
movl %eax, %ebp
movq 0x8(%r14), %rcx
xorl %r15d, %r15d
movl 0x4(%r14), %eax
imull %r15d, %eax
addl %ebx, %eax
movl (%rcx,%rax,4), %esi
movl %ebp, %edi
callq 0x146e
movq 0x8(%r14), %rcx
movl 0x4(%r14), %edx
imull %r15d, %edx
addl %ebx, %edx
movl %eax, (%rcx,%rdx,4)
incl %r15d
cmpl (%r14), %r15d
jb 0x2711
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vrancurel[P]ec/mat.c
// Function: mat_mult
void mat_mult(t_vec *output, t_mat *a, t_vec *b)
{
  int i, j;

  assert(output->n == b->n);
  assert(output->n == a->n_cols);
  for (i = 0;i < a->n_rows;i++) {
    for (j = 0;j < a->n_cols;j++) {
      int x = gmul(MAT_ITEM(a, i, j), VEC_ITEM(b, j));
      if (0 == j)
        VEC_ITEM(output, i) = x;
      else
        VEC_ITEM(output, i) ^= x;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl (%rdi), %eax
cmpl (%rdx), %eax
jne 0x2c48
movq %rsi, %r14
cmpl 0x4(%rsi), %eax
jne 0x2c67
movl (%r14), %ecx
testl %ecx, %ecx
je 0x2c3e
movq %rdx, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x0, %edx
testl %eax, %eax
je 0x2c32
xorl %r13d, %r13d
movq 0x8(%r14), %rcx
imull %r12d, %eax
addl %r13d, %eax
movl (%rcx,%rax,4), %edi
movq 0x8(%rbx), %rax
movl (%rax,%r13,4), %esi
callq 0x146e
movq 0x8(%r15), %rcx
testq %r13, %r13
je 0x2c1d
xorl (%rcx,%r12,4), %eax
movl %eax, (%rcx,%r12,4)
incq %r13
movl 0x4(%r14), %eax
cmpq %rax, %r13
jb 0x2bf5
movl (%r14), %ecx
movl %eax, %edx
incq %r12
movl %ecx, %esi
movl %edx, %eax
cmpq %rsi, %r12
jb 0x2be9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x73e(%rip), %rdi       # 0x338d
leaq 0x6da(%rip), %rsi       # 0x3330
leaq 0x742(%rip), %rcx       # 0x339f
movl $0x10b, %edx            # imm = 0x10B
callq 0x1090
leaq 0x75a(%rip), %rdi       # 0x33c8
leaq 0x6bb(%rip), %rsi       # 0x3330
leaq 0x723(%rip), %rcx       # 0x339f
movl $0x10c, %edx            # imm = 0x10C
callq 0x1090
nop
// File: /workspace/github_c_makefile_star2_O3/vrancurel[P]ec/vec.c
// Function: vec_xcalloc
t_vec *vec_xcalloc(u_int n)
{
  t_vec *vec;

  vec = xmalloc(sizeof (*vec));
  vec->n = n;
  vec->mem = xmalloc(sizeof (int) * n);
  vec_zero(vec);
  return vec;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x10, %edi
callq 0x2d06
movq %rax, %r14
movl %ebx, (%rax)
movl %ebx, %edi
shlq $0x2, %rdi
callq 0x2d06
movq %rax, 0x8(%r14)
movl (%r14), %edx
shlq $0x2, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x10a0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
leal -0x1(%r14), %eax
testl %eax, %edi
jne 0x2548
movl $0x1, %edi
movl $0x18, %esi
callq 0x2130
testq %rax, %rax
je 0x2548
movq %rax, %rbx
movl %r14d, (%rax)
movl %r14d, %edi
movl $0x18, %esi
callq 0x2130
movq %rax, 0x10(%rbx)
jmp 0x254a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %edi, %ebx
leaq 0x30(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x264b
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %rdi, 0x10(%rdx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x20a0
movq 0x3977(%rip), %rax      # 0x5ff8
movq (%rax), %r15
movq (%r14), %r12
movl %ebx, %edi
callq 0x2250
leaq 0x196f(%rip), %rsi      # 0x4004
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2150
movq (%r14), %rdi
callq 0x2030
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x2050
movq %rax, %r15
movl $0x0, (%rax)
movq %rsp, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x2170
movslq (%r15), %rcx
testq %rcx, %rcx
je 0x2792
negq %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testq %rax, %rax
js 0x27a8
testq %rbx, %rbx
je 0x2787
movq (%rsp), %rcx
subq %r14, %rcx
movq %rcx, (%rbx)
jmp 0x2787
movq $-0x22, %rax
jmp 0x2787
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsp, %r14
movq %r14, %rsi
movl $0xa, %edx
callq 0x2170
movq %rax, %rbx
movq (%r14), %r14
movq %r14, %rdi
callq 0x20d0
movq %rax, %rcx
movq $-0x16, %rax
cmpq $0x1, %rcx
ja 0x2842
testq %r14, %r14
je 0x2836
movzbl (%r14), %ecx
cmpl $0x63, %ecx
jg 0x2802
cmpl $0x4c, %ecx
jg 0x281a
cmpl $0x44, %ecx
je 0x283b
cmpl $0x48, %ecx
je 0x2811
jmp 0x2842
cmpl $0x6c, %ecx
jg 0x2826
cmpl $0x64, %ecx
je 0x283b
cmpl $0x68, %ecx
jne 0x2842
imulq $0xe10, %rbx, %rax      # imm = 0xE10
jmp 0x2842
cmpl $0x4d, %ecx
je 0x2830
cmpl $0x53, %ecx
je 0x2836
jmp 0x2842
cmpl $0x73, %ecx
je 0x2836
cmpl $0x6d, %ecx
jne 0x2842
imulq $0x3c, %rbx, %rax
jmp 0x2842
movq %rbx, %rax
jmp 0x2842
imulq $0x15180, %rbx, %rax    # imm = 0x15180
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x80, %edi
callq 0x20c0
testl %eax, %eax
je 0x2951
movq $-0x1, %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
xorl %ebp, %ebp
movq %r15, %rax
incq %r15
cmpq $0x3ff, %r15            # imm = 0x3FF
ja 0x28e8
movq %r15, %rsi
movl $0x1, %edx
movl %r15d, %ecx
shlq %cl, %rdx
shrq $0x6, %rsi
andq (%r14,%rsi,8), %rdx
testq %r13, %r13
jne 0x28de
testq %rdx, %rdx
je 0x28de
testq %r12, %r12
je 0x28bd
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x2110
movq %rbx, %rdi
leaq 0x1837(%rip), %rsi      # 0x40fe
movq %r15, %rdx
xorl %eax, %eax
callq 0x2150
movl $0x1, %ecx
movl $0x1, %r12d
jmp 0x290d
movl $0x1, %ecx
testq %rdx, %rdx
jne 0x2910
cmpq $0x2, %r13
jb 0x290b
sete %cl
movzbl %cl, %edx
xorl $0x2d, %edx
movq %rbx, %rdi
leaq 0x17fb(%rip), %rsi      # 0x40fc
movq %rax, %rcx
xorl %eax, %eax
callq 0x2150
xorl %ecx, %ecx
xorl %r13d, %r13d
addq %rcx, %r13
addq %rcx, %rbp
movl $0x80, %edi
movq %r14, %rsi
callq 0x20c0
movl %eax, %eax
cmpq %rax, %rbp
jb 0x287c
cmpq $0x2, %r13
jb 0x2951
sete %al
movzbl %al, %edx
xorl $0x2d, %edx
leaq 0x17b8(%rip), %rsi      # 0x40fc
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2150
movl $0x80, %edi
movq %r14, %rsi
callq 0x20c0
movl %eax, %ebp
movl $0x80, %edi
movq %r14, %rsi
callq 0x20c0
xorl %r12d, %r12d
xorl %r15d, %r15d
testl %eax, %eax
je 0x29b8
xorl %r13d, %r13d
xorl %eax, %eax
cmpl $0x3ff, %r12d           # imm = 0x3FF
ja 0x2998
movl %r12d, %eax
shrl $0x6, %eax
movq (%r14,%rax,8), %rcx
xorl %eax, %eax
btq %r12, %rcx
setb %al
addl %eax, %r13d
movl %r12d, %ecx
shll %cl, %eax
orq %rax, %r15
incl %r12d
movl $0x80, %edi
movq %r14, %rsi
callq 0x20c0
cmpl %eax, %r13d
jb 0x297a
leaq 0x164d(%rip), %rsi      # 0x400c
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2150
// File: /workspace/github_c_makefile_star2_O3/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
movq %rsi, %r12
movq %rdi, %rbx
movq $0x0, (%rsp)
cmpb $0x30, (%rsi)
jne 0x2a30
cmpb $0x78, 0x1(%r12)
jne 0x2a30
movq %rsp, %rdx
movq %r12, %rdi
movl $0x10, %esi
callq 0x2b05
xorl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
btq %rcx, %rax
jae 0x2a22
orq %rdx, (%rbx)
incq %rcx
cmpq $0x40, %rcx
jne 0x2a11
jmp 0x2af5
movq %rsp, %r14
movq %r12, %rdi
movl $0xa, %esi
movq %r14, %rdx
callq 0x2b05
movq %rax, %r15
movq (%r14), %rax
leaq (%r12,%rax), %r14
cmpb $0x2d, (%r12,%rax)
jne 0x2a79
leaq 0x1(%r14), %rdi
movq %rsp, %r12
movl $0xa, %esi
movq %r12, %rdx
callq 0x2b05
movq (%r12), %rcx
addq %rcx, %r14
incq %r14
testq %rcx, %rcx
jne 0x2a7c
jmp 0x2aa9
movl %r15d, %eax
incl %eax
cmpl $0x401, %eax            # imm = 0x401
jb 0x2aae
leaq 0x158e(%rip), %rdi      # 0x401a
leaq 0x15c2(%rip), %rsi      # 0x4055
leaq 0x15c6(%rip), %rdx      # 0x4060
movl %eax, %ecx
movl $0x400, %r8d            # imm = 0x400
xorl %eax, %eax
callq 0x26b7
movl $0x400, %eax            # imm = 0x400
cmpl %r15d, %eax
jbe 0x2ad3
movl %r15d, %ecx
movl %eax, %eax
movl $0x1, %edx
shlq %cl, %rdx
movq %rcx, %rsi
shrq $0x6, %rsi
orq %rdx, (%rbx,%rsi,8)
incq %rcx
cmpq %rcx, %rax
jne 0x2ab8
cmpb $0x2c, (%r14)
jne 0x2af5
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29dc
testq %rax, %rax
js 0x2af9
movq (%rsp), %rcx
addq %rcx, %rax
jmp 0x2af9
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x274f
testq %rax, %rax
js 0x2b15
popq %rbx
retq
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_c_makefile_star2_O3/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 0x2b45
callq 0x2050
cmpl $0x4, (%rax)
je 0x2b28
jmp 0x2b97
movl %eax, %ebx
testl %eax, %eax
js 0x2b92
movl $0x1e, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
callq 0x2180
movq %rax, (%r14)
testq %rax, %rax
je 0x2b9f
decq %r15
movl %ebx, %edi
movq %rax, %rsi
movq %r15, %rdx
callq 0x2120
movq %rax, %r15
testl %r15d, %r15d
js 0x2ba7
movq (%r14), %rax
movl %r15d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movb $0x0, (%rax,%rcx)
jmp 0x2bc0
callq 0x2050
xorl %r15d, %r15d
subl (%rax), %r15d
jmp 0x2bc7
movl $0xfffffff4, %r15d      # imm = 0xFFFFFFF4
jmp 0x2bc0
callq 0x2050
movl (%rax), %eax
movl %eax, %r15d
negl %r15d
testl %eax, %eax
jle 0x2bc0
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_O3/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 0x2bdd
popq %rcx
retq
callq 0x2050
movl (%rax), %edi
leaq 0x1482(%rip), %rsi      # 0x406d
leaq 0x1463(%rip), %rdx      # 0x4055
leaq 0x1486(%rip), %rcx      # 0x407f
xorl %eax, %eax
callq 0x25e8
// File: /workspace/github_c_makefile_star2_O3/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 0x2bd0
movq %rax, %r14
movq %rax, %rdi
callq 0x2160
leaq 0x1460(%rip), %rsi      # 0x4089
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x21a0
testl %eax, %eax
js 0x2c6e
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 0x1413(%rip), %rsi      # 0x408f
leaq 0x13d2(%rip), %rdx      # 0x4055
leaq 0x1419(%rip), %rcx      # 0x40a3
xorl %eax, %eax
callq 0x25e8
// File: /workspace/github_c_makefile_star2_O3/igaw[P]jitterdebugger/jd_utils.c
// Function: jd_cp
void jd_cp(const char *src, const char *path)
{
	char buf[BUFSIZ];
	FILE *fds, *fdd;
	size_t n;

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x13fe(%rip), %rsi      # 0x40ac
callq 0x21d0
testq %rax, %rax
je 0x2d54
movq %rax, %r14
leaq 0x15eb(%rip), %rdx      # 0x42b1
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2c00
testq %rax, %rax
je 0x2d5d
movq %rax, %r15
movq %rsp, %r12
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %r12, %rdi
movq %r14, %rcx
callq 0x2090
testq %rax, %rax
je 0x2d34
movq %rax, %r13
movl $0x1, %esi
movq %r12, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0x2220
cmpq %r13, %rax
je 0x2ce0
leaq 0x13c2(%rip), %rdi      # 0x40de
leaq 0x1332(%rip), %rsi      # 0x4055
leaq 0x13ae(%rip), %rdx      # 0x40d8
movq %rbx, %rcx
xorl %eax, %eax
callq 0x26b7
movq %r15, %rdi
callq 0x20b0
movq %r14, %rdi
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x20b0
leaq 0x1353(%rip), %rdi      # 0x40ae
jmp 0x2d6b
xorl %edi, %edi
callq 0x20b0
leaq 0x1373(%rip), %rdi      # 0x40de
leaq 0x12e3(%rip), %rsi      # 0x4055
leaq 0x135f(%rip), %rdx      # 0x40d8
movq %rbx, %rcx
xorl %eax, %eax
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x26b7
nop
// File: /workspace/github_c_makefile_star2_O3/igaw[P]jitterdebugger/jd_samples_csv.c
// Function: output_csv
static int output_csv(struct jd_samples_info *info, FILE *input)
{
	struct latency_sample sample;
	FILE *output;

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

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

	fclose(output);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
leaq 0x1396(%rip), %rsi      # 0x4145
leaq 0x14fb(%rip), %rdx      # 0x42b1
callq 0x2c00
movq %rax, %r14
testq %rax, %rax
jne 0x2de9
callq 0x2050
movl (%rax), %edi
movq (%r15), %r8
leaq 0x137d(%rip), %rsi      # 0x4151
leaq 0x13ab(%rip), %rdx      # 0x4186
leaq 0x13b5(%rip), %rcx      # 0x4197
xorl %eax, %eax
callq 0x25e8
leaq 0xc(%rsp), %rdi
movl $0x1c, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2090
testq %rax, %rax
je 0x2e4b
leaq 0x1396(%rip), %r15      # 0x41a2
leaq 0xc(%rsp), %r12
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2150
movl $0x1c, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x2090
testq %rax, %rax
jne 0x2e11
movq %r14, %rdi
callq 0x20b0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2eb7
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x2e83
movl $0x1, %edi
movl $0x10, %esi
callq 0x2130
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x2ebc
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22d9
callq 0x22b4
// File: /workspace/github_c_makefile_star2_O3/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 0x3289(%rip), %r14      # 0x6180
movq (%r14), %rbx
testq %rbx, %rbx
je 0x2f16
addq $0x8, %r14
callq *0x8(%rbx)
testl %eax, %eax
jne 0x2f1e
movq (%r14), %rbx
addq $0x8, %r14
testq %rbx, %rbx
jne 0x2f03
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x22fe
// File: /workspace/github_c_makefile_star2_O3/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 0x127e(%rip), %rdi      # 0x4473
callq 0x2070
leaq 0x1290(%rip), %rdi      # 0x4491
callq 0x2070
movl $0xa, %edi
callq 0x2040
leaq 0x12b1(%rip), %rdi      # 0x44c8
callq 0x2070
leaq 0x12ac(%rip), %rdi      # 0x44cf
callq 0x2070
leaq 0x12be(%rip), %rdi      # 0x44ed
callq 0x2070
leaq 0x12e2(%rip), %rdi      # 0x451d
callq 0x2070
leaq 0x1311(%rip), %rdi      # 0x4558
callq 0x2070
movl %ebx, %edi
callq 0x2210
// File: /workspace/github_c_makefile_star2_O3/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 0xfe2(%rip), %xmm0      # 0x4260
movaps %xmm0, (%rdx)
leaq 0x8(%rsp), %rcx
xorl %edi, %edi
callq 0x2230
testl %eax, %eax
jns 0x32b4
callq 0x2050
movl (%rax), %edi
leaq 0x108a(%rip), %rsi      # 0x4329
leaq 0x1042(%rip), %rdx      # 0x42e8
leaq 0x1093(%rip), %rcx      # 0x4340
xorl %eax, %eax
callq 0x25e8
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 0x32fc
movq 0x18(%rax), %rsi
movl 0x10(%rax), %edx
movl %ebx, %edi
callq 0x21b0
testl %eax, %eax
je 0x3301
movl %ebx, %edi
callq 0x2100
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x32bc
movq %r14, %rdi
callq 0x2260
leaq 0x40(%rsp), %r14
movq 0x2cb3(%rip), %r15      # 0x5fc8
leaq 0xfcc(%rip), %r12       # 0x42e8
leaq 0x101d(%rip), %r13      # 0x4340
leaq 0x1023(%rip), %rbp      # 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 0x3383
movq (%r15), %rcx
movl $0x578, %esi            # imm = 0x578
movl $0x1, %edx
movq %r14, %rdi
callq 0x2220
cmpq $0x578, %rax            # imm = 0x578
je 0x332a
callq 0x2050
movl (%rax), %edi
leaq 0xffe(%rip), %rsi       # 0x4372
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x25e8
jmp 0x332a
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x26b7
jmp 0x332a
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x61, %edi
callq 0x794e
movq %rax, %rbx
movl $0x62, %edi
callq 0x794e
xorl %ebp, %ebp
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7f80
movq 0x16c23(%rip), %rsi     # 0x17fc8
leaq 0x122(%rip), %rdx       # 0x14ce
leaq 0xdc51(%rip), %rcx      # 0xf004
movq %rax, %rdi
callq 0x7b4f
movq %rax, %rbx
leaq 0xdc4c(%rip), %rdi      # 0xf011
leaq 0x110e0(%rip), %rsi     # 0x124ac
movq %rsp, %r15
movq %rax, %rdx
movq %r15, %rcx
callq 0x6bd7
movl %eax, %r14d
leaq 0xdc64(%rip), %rsi      # 0xf048
leaq 0xdc2b(%rip), %rdx      # 0xf016
movl %eax, %edi
movl $0x12, %ecx
callq 0x4094
movq (%r15), %rax
cmpb $0x61, (%rax)
jne 0x1409
xorl %ebp, %ebp
cmpb $0x0, 0x1(%rax)
sete %bpl
leaq 0xdc1a(%rip), %rsi      # 0xf02a
leaq 0xdbff(%rip), %rdx      # 0xf016
movl %ebp, %edi
movl $0x13, %ecx
callq 0x4094
movq (%rsp), %rdi
testl %r14d, %r14d
je 0x1433
callq 0x1270
jmp 0x1438
callq 0x56b0
leaq 0xdbd2(%rip), %rdi      # 0xf011
leaq 0x1006c(%rip), %rsi     # 0x114b2
movq %rsp, %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6bd7
movl %eax, %ebp
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xdbe2(%rip), %rsi      # 0xf047
leaq 0xdbaa(%rip), %r15      # 0xf016
movq %r15, %rdx
movl $0x17, %ecx
callq 0x4094
movq (%r14), %rax
movq 0x30(%rax), %rdi
leaq 0xdb7d(%rip), %rsi      # 0xf004
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xdbb5(%rip), %rsi      # 0xf050
movq %r15, %rdx
movl $0x18, %ecx
callq 0x4094
movq (%r14), %rdi
testl %ebp, %ebp
je 0x14b6
callq 0x1270
jmp 0x14bb
callq 0x56b0
movq %rbx, %rdi
callq 0x708b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/combinators.c
// Function: test_check_with
void test_check_with(void) {
  int success;
  mpc_result_t  r;
  mpc_parser_t* p = mpc_check_with(mpc_or(2, mpc_char('a'), mpc_char('b')), free, check_is, (void*)"a", "Expected 'a'");

  success = mpc_parse("test", "a", p, &r);
  PT_ASSERT(success);
  if (success) PT_ASSERT_STR_EQ(r.output, "a");
  if (success) free(r.output); else mpc_err_delete(r.error);

  success = mpc_parse("test", "b", p, &r);
  PT_ASSERT(!success);
  if (!success) PT_ASSERT_STR_EQ(r.error->failure, "Expected 'a'");
  if (success) free(r.output); else mpc_err_delete(r.error);

  mpc_delete(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x61, %edi
callq 0x794e
movq %rax, %rbx
movl $0x62, %edi
callq 0x794e
xorl %ebp, %ebp
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7f80
movq 0x16aad(%rip), %rsi     # 0x17fc8
leaq 0x12a(%rip), %rdx       # 0x164c
leaq 0x10f83(%rip), %r14     # 0x124ac
leaq 0xdad4(%rip), %r8       # 0xf004
movq %rax, %rdi
movq %r14, %rcx
callq 0x7bb3
movq %rax, %rbx
leaq 0xdacc(%rip), %rdi      # 0xf011
movq %rsp, %r15
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x6bd7
movl %eax, %r14d
leaq 0xdae8(%rip), %rsi      # 0xf048
leaq 0xdaaf(%rip), %rdx      # 0xf016
movl %eax, %edi
movl $0x24, %ecx
callq 0x4094
movq (%r15), %rdi
testl %r14d, %r14d
je 0x15af
cmpb $0x61, (%rdi)
jne 0x158a
xorl %ebp, %ebp
cmpb $0x0, 0x1(%rdi)
sete %bpl
leaq 0xda99(%rip), %rsi      # 0xf02a
leaq 0xda7e(%rip), %rdx      # 0xf016
movl %ebp, %edi
movl $0x25, %ecx
callq 0x4094
movq (%rsp), %rdi
callq 0x1270
jmp 0x15b4
callq 0x56b0
leaq 0xda56(%rip), %rdi      # 0xf011
leaq 0xfef0(%rip), %rsi      # 0x114b2
movq %rsp, %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6bd7
movl %eax, %ebp
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xda66(%rip), %rsi      # 0xf047
leaq 0xda2e(%rip), %rdx      # 0xf016
movl $0x29, %ecx
callq 0x4094
movq (%r14), %rdi
testl %ebp, %ebp
je 0x1600
callq 0x1270
jmp 0x1639
movq 0x30(%rdi), %rdi
leaq 0xd9f9(%rip), %rsi      # 0xf004
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xda31(%rip), %rsi      # 0xf050
leaq 0xd9f0(%rip), %rdx      # 0xf016
movl $0x2a, %ecx
callq 0x4094
movq (%rsp), %rdi
callq 0x56b0
movq %rbx, %rdi
callq 0x708b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x61, %edi
callq 0x794e
movq %rax, %rbx
movl $0x62, %edi
callq 0x794e
xorl %ebp, %ebp
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7f80
movq 0x1692f(%rip), %rsi     # 0x17fc8
leaq -0x1d2(%rip), %rdx      # 0x14ce
leaq 0xd9d9(%rip), %rcx      # 0xf080
leaq 0x10dfe(%rip), %r14     # 0x124ac
movq %rax, %rdi
movq %r14, %r8
xorl %eax, %eax
callq 0x7c25
movq %rax, %rbx
leaq 0xd94c(%rip), %rdi      # 0xf011
movq %rsp, %r15
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x6bd7
movl %eax, %r14d
leaq 0xd968(%rip), %rsi      # 0xf048
leaq 0xd92f(%rip), %rdx      # 0xf016
movl %eax, %edi
movl $0x36, %ecx
callq 0x4094
movq (%r15), %rax
cmpb $0x61, (%rax)
jne 0x1705
xorl %ebp, %ebp
cmpb $0x0, 0x1(%rax)
sete %bpl
leaq 0xd91e(%rip), %rsi      # 0xf02a
leaq 0xd903(%rip), %rdx      # 0xf016
movl %ebp, %edi
movl $0x37, %ecx
callq 0x4094
movq (%rsp), %rdi
testl %r14d, %r14d
je 0x172f
callq 0x1270
jmp 0x1734
callq 0x56b0
leaq 0xd8d6(%rip), %rdi      # 0xf011
leaq 0xfd70(%rip), %rsi      # 0x114b2
movq %rsp, %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6bd7
movl %eax, %ebp
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd8e6(%rip), %rsi      # 0xf047
leaq 0xd8ae(%rip), %r15      # 0xf016
movq %r15, %rdx
movl $0x3b, %ecx
callq 0x4094
movq (%r14), %rax
movq 0x30(%rax), %rdi
leaq 0xd881(%rip), %rsi      # 0xf004
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd8b9(%rip), %rsi      # 0xf050
movq %r15, %rdx
movl $0x3c, %ecx
callq 0x4094
movq (%r14), %rdi
testl %ebp, %ebp
je 0x17b2
callq 0x1270
jmp 0x17b7
callq 0x56b0
movq %rbx, %rdi
callq 0x708b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/combinators.c
// Function: test_check_withf
void test_check_withf(void) {
  int success;
  mpc_result_t  r;
  mpc_parser_t* p = mpc_check_withf(mpc_or(2, mpc_char('a'), mpc_char('b')), free, check_is, (void*)"a", "Expected '%s'", "a");

  success = mpc_parse("test", "a", p, &r);
  PT_ASSERT(success);
  if (success) PT_ASSERT_STR_EQ(r.output, "a");
  if (success) free(r.output); else mpc_err_delete(r.error);

  success = mpc_parse("test", "b", p, &r);
  PT_ASSERT(!success);
  if (!success) PT_ASSERT_STR_EQ(r.error->failure, "Expected 'a'");
  if (success) free(r.output); else mpc_err_delete(r.error);

  mpc_delete(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x61, %edi
callq 0x794e
movq %rax, %rbx
movl $0x62, %edi
callq 0x794e
xorl %ebp, %ebp
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7f80
movq 0x167c5(%rip), %rsi     # 0x17fc8
leaq -0x1be(%rip), %rdx      # 0x164c
leaq 0xd86f(%rip), %r8       # 0xf080
leaq 0x10c94(%rip), %r14     # 0x124ac
movq %rax, %rdi
movq %r14, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x7cf7
movq %rax, %rbx
leaq 0xd7df(%rip), %rdi      # 0xf011
movq %rsp, %r15
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x6bd7
movl %eax, %r14d
leaq 0xd7fb(%rip), %rsi      # 0xf048
leaq 0xd7c2(%rip), %rdx      # 0xf016
movl %eax, %edi
movl $0x48, %ecx
callq 0x4094
movq (%r15), %rdi
testl %r14d, %r14d
je 0x189c
cmpb $0x61, (%rdi)
jne 0x1877
xorl %ebp, %ebp
cmpb $0x0, 0x1(%rdi)
sete %bpl
leaq 0xd7ac(%rip), %rsi      # 0xf02a
leaq 0xd791(%rip), %rdx      # 0xf016
movl %ebp, %edi
movl $0x49, %ecx
callq 0x4094
movq (%rsp), %rdi
callq 0x1270
jmp 0x18a1
callq 0x56b0
leaq 0xd769(%rip), %rdi      # 0xf011
leaq 0xfc03(%rip), %rsi      # 0x114b2
movq %rsp, %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6bd7
movl %eax, %ebp
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd779(%rip), %rsi      # 0xf047
leaq 0xd741(%rip), %rdx      # 0xf016
movl $0x4d, %ecx
callq 0x4094
movq (%r14), %rdi
testl %ebp, %ebp
je 0x18ed
callq 0x1270
jmp 0x1926
movq 0x30(%rdi), %rdi
leaq 0xd70c(%rip), %rsi      # 0xf004
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd744(%rip), %rsi      # 0xf050
leaq 0xd703(%rip), %rdx      # 0xf016
movl $0x4e, %ecx
callq 0x4094
movq (%rsp), %rdi
callq 0x56b0
movq %rbx, %rdi
callq 0x708b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 -0x5d5(%rip), %rdi      # 0x136c
leaq 0xd746(%rip), %rsi      # 0xf08e
leaq 0xd74a(%rip), %rbx      # 0xf099
movq %rbx, %rdx
callq 0x410b
leaq -0x47c(%rip), %rdi      # 0x14e2
leaq 0xd746(%rip), %rsi      # 0xf0ab
movq %rbx, %rdx
callq 0x410b
leaq -0x314(%rip), %rdi      # 0x1660
leaq 0xd740(%rip), %rsi      # 0xf0bb
movq %rbx, %rdx
callq 0x410b
leaq -0x1c0(%rip), %rdi      # 0x17ca
leaq 0xd737(%rip), %rsi      # 0xf0c8
movq %rbx, %rdx
popq %rbx
jmp 0x410b
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1f2d
leaq 0xd200(%rip), %rcx      # 0xf0dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rcx
movq 0x10(%rbx), %rsi
movl (%rcx), %eax
cltd
idivl (%rsi)
movl %edx, (%rcx)
jmp 0x1f2d
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rcx), %ecx
addl %ecx, (%rax)
jmp 0x1f2d
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rax), %edx
imull (%rcx), %edx
movl %edx, (%rax)
jmp 0x1f2d
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rcx), %ecx
subl %ecx, (%rax)
jmp 0x1f2d
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_O3/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 0x792a
leaq 0x6452(%rip), %rbx      # 0x83c6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7eb4
leaq 0x7fe7(%rip), %rsi      # 0x9f6d
movq %rax, %rdi
callq 0x7aef
movq %rax, %r14
movq %rax, 0x10(%rsp)
callq 0x792a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7eb4
leaq 0x800d(%rip), %rsi      # 0x9fba
movq %rax, %rdi
callq 0x7aef
movq %rax, %r12
callq 0x792a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7eb4
leaq 0x802a(%rip), %rsi      # 0x9ff9
movq %rax, %rdi
callq 0x7aef
movq %rax, 0x8(%rsp)
leaq 0xd499(%rip), %rbx      # 0xf47c
leaq 0xd493(%rip), %rdx      # 0xf47d
leaq -0x43a(%rip), %rbp      # 0x1bb7
movq 0x15fd0(%rip), %r8      # 0x17fc8
leaq -0x437(%rip), %r13      # 0x1bc8
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rcx
movq %r8, %r14
movq %r13, %r9
callq 0xa93d
leaq 0xd471(%rip), %rsi      # 0xf48b
leaq 0xd123(%rip), %r15      # 0xf144
movl %eax, %edi
movq %r15, %rdx
movl $0x67, %ecx
callq 0x4094
leaq 0xd4a7(%rip), %rdx      # 0xf4de
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rcx
movq %r14, %r8
movq %r13, %r9
callq 0xa93d
leaq 0xd499(%rip), %rsi      # 0xf4eb
movl %eax, %edi
movq %r15, %rdx
movl $0x68, %ecx
callq 0x4094
leaq 0xd477(%rip), %rdx      # 0xf4df
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
leaq 0xd405(%rip), %rsi      # 0xf47c
movq %rbp, %rcx
movq %r14, %r8
movq %r13, %r9
callq 0xa93d
leaq 0xd4b1(%rip), %rsi      # 0xf53d
movl %eax, %edi
movq %r15, %rdx
movl $0x69, %ecx
callq 0x4094
movq 0x10(%rsp), %rdi
callq 0x708b
movq %r12, %rdi
callq 0x708b
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x708b
// File: /workspace/github_c_makefile_star2_O3/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 0x8587
leaq 0x62ec(%rip), %rsi      # 0x83c6
movq 0x15ee7(%rip), %rcx     # 0x17fc8
movl $0x3, %edi
movq %rax, %rdx
callq 0x7f0e
movq %rax, %rbx
leaq 0xcf19(%rip), %r12      # 0xf011
leaq 0xd48e(%rip), %rbp      # 0xf58d
movq %rsp, %r14
movq %r12, %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x6bd7
leaq 0xcf2e(%rip), %rsi      # 0xf048
leaq 0xd023(%rip), %r15      # 0xf144
movl %eax, %edi
movq %r15, %rdx
movl $0x78, %ecx
callq 0x4094
movq (%r14), %rdi
movq %rbp, %rsi
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xd447(%rip), %r13      # 0xf591
movq %r13, %rsi
movq %r15, %rdx
movl $0x79, %ecx
callq 0x4094
movq (%r14), %rdi
callq 0x1270
leaq 0xd447(%rip), %rsi      # 0xf5b0
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6bd7
movl %eax, %edi
leaq 0xcec8(%rip), %rsi      # 0xf048
movq %r15, %rdx
movl $0x7d, %ecx
callq 0x4094
movq (%r14), %rdi
movq %rbp, %rsi
callq 0x1130
xorl %edi, %edi
testl %eax, %eax
sete %dil
movq %r13, %rsi
movq %r15, %rdx
movl $0x7e, %ecx
callq 0x4094
movq (%r14), %rdi
callq 0x1270
leaq 0xd3f7(%rip), %rsi      # 0xf5b6
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6bd7
movl %eax, %edi
leaq 0xce72(%rip), %rsi      # 0xf048
movq %r15, %rdx
movl $0x82, %ecx
callq 0x4094
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 0x4094
movq (%r14), %rdi
callq 0x1270
leaq 0xd3a7(%rip), %rsi      # 0xf5bc
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6bd7
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xce15(%rip), %rsi      # 0xf047
movq %r15, %rdx
movl $0x87, %ecx
callq 0x4094
movq (%r14), %rdi
callq 0x56b0
movq %rbx, %rdi
callq 0x708b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/orangeduck[P]mpc/tests/core.c
// Function: test_reader
void test_reader(void) {

  mpc_parser_t* Line = mpc_many(
    mpcf_strfold,
    mpc_apply(mpc_re("[^\\n]*(\\n|$)"), read_line));

  line_count = 0;

  PT_ASSERT(mpc_test_pass(Line,
    "hello\nworld\n\nthis\nis\ndan",
    "hello\nworld\n\nthis\nis\ndan", streq, free, strprint));

  PT_ASSERT(line_count == 6);

  line_count = 0;

  PT_ASSERT(mpc_test_pass(Line,
    "abcHVwufvyuevuy3y436782\n\n\nrehre\nrew\n-ql.;qa\neg",
    "abcHVwufvyuevuy3y436782\n\n\nrehre\nrew\n-ql.;qa\neg", streq, free, strprint));

  PT_ASSERT(line_count == 7);

  mpc_delete(Line);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xd119(%rip), %rdi      # 0xf63d
callq 0x9153
leaq 0xfe(%rip), %rsi        # 0x262e
movq %rax, %rdi
callq 0x7aef
leaq 0x5e87(%rip), %rdi      # 0x83c6
movq %rax, %rsi
callq 0x7eb4
movq %rax, %rbx
xorl %ebp, %ebp
movl %ebp, 0x15c92(%rip)     # 0x181e4
leaq 0xd0f1(%rip), %rdx      # 0xf64a
leaq -0x9a9(%rip), %r15      # 0x1bb7
movq 0x15a61(%rip), %r12     # 0x17fc8
leaq -0x9a6(%rip), %r13      # 0x1bc8
movq %rax, %rdi
movq %rdx, %rsi
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0xa93d
leaq 0xd0da(%rip), %rsi      # 0xf663
leaq 0xcbb4(%rip), %r14      # 0xf144
movl %eax, %edi
movq %r14, %rdx
movl $0xc5, %ecx
callq 0x4094
xorl %edi, %edi
cmpl $0x6, 0x15c3c(%rip)     # 0x181e4
sete %dil
leaq 0xd11d(%rip), %rsi      # 0xf6d0
movq %r14, %rdx
movl $0xc7, %ecx
callq 0x4094
movl %ebp, 0x15c1e(%rip)     # 0x181e4
leaq 0xd113(%rip), %rdx      # 0xf6e0
movq %rbx, %rdi
movq %rdx, %rsi
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0xa93d
leaq 0xd127(%rip), %rsi      # 0xf70f
movl %eax, %edi
movq %r14, %rdx
movl $0xcd, %ecx
callq 0x4094
xorl %edi, %edi
cmpl $0x7, 0x15be4(%rip)     # 0x181e4
sete %dil
leaq 0xd19f(%rip), %rsi      # 0xf7aa
movq %r14, %rdx
movl $0xcf, %ecx
callq 0x4094
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x708b
// File: /workspace/github_c_makefile_star2_O3/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 0xd177(%rip), %rdi      # 0xf7ba
callq 0x9153
movq %rax, %rdi
callq 0x8f58
leaq 0x9c(%rip), %rsi        # 0x26f3
movq %rax, %rdi
callq 0x7aef
leaq 0x5d60(%rip), %rdi      # 0x83c6
movq %rax, %rsi
callq 0x7eb4
movq %rax, %rbx
movl $0x0, 0x15b6d(%rip)     # 0x181e8
leaq 0xd156(%rip), %rsi      # 0xf7d8
leaq 0xd17b(%rip), %rdx      # 0xf804
leaq -0xad9(%rip), %rcx      # 0x1bb7
movq 0x15931(%rip), %r8      # 0x17fc8
leaq -0xad6(%rip), %r9       # 0x1bc8
movq %rax, %rdi
callq 0xa93d
leaq 0xd171(%rip), %rsi      # 0xf81e
leaq 0xca90(%rip), %r14      # 0xf144
movl %eax, %edi
movq %r14, %rdx
movl $0xe7, %ecx
callq 0x4094
xorl %edi, %edi
cmpl $0x9, 0x15b1c(%rip)     # 0x181e8
sete %dil
leaq 0xd1c3(%rip), %rsi      # 0xf89a
movq %r14, %rdx
movl $0xe9, %ecx
callq 0x4094
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x708b
// File: /workspace/github_c_makefile_star2_O3/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 0xd19e(%rip), %rdi      # 0xf8ab
callq 0x9153
movq %rax, %rbx
leaq 0xe3c9(%rip), %rdx      # 0x10ae5
leaq -0xb6c(%rip), %r14      # 0x1bb7
movq 0x1589e(%rip), %r15     # 0x17fc8
leaq -0xb69(%rip), %r12      # 0x1bc8
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa93d
leaq 0xd167(%rip), %rsi      # 0xf8b3
leaq 0xc9f1(%rip), %r13      # 0xf144
movl %eax, %edi
movq %r13, %rdx
movl $0xf3, %ecx
callq 0x4094
leaq 0xf28b(%rip), %rdx      # 0x119f4
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xa93d
leaq 0xd16a(%rip), %rsi      # 0xf8ee
movl %eax, %edi
movq %r13, %rdx
movl $0xf4, %ecx
callq 0x4094
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x708b
// File: /workspace/github_c_makefile_star2_O3/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 -0x10a5(%rip), %rdi     # 0x199c
leaq 0xd113(%rip), %rsi      # 0xfb5b
leaq 0xd117(%rip), %rbx      # 0xfb66
movq %rbx, %rdx
callq 0x410b
leaq -0xe85(%rip), %rdi      # 0x1bd9
leaq 0xd10c(%rip), %rsi      # 0xfb71
movq %rbx, %rdx
callq 0x410b
leaq -0xb1a(%rip), %rdi      # 0x1f5a
leaq 0xd101(%rip), %rsi      # 0xfb7c
movq %rbx, %rdx
callq 0x410b
leaq -0x9c7(%rip), %rdi      # 0x20c3
leaq 0xd0f6(%rip), %rsi      # 0xfb87
movq %rbx, %rdx
callq 0x410b
leaq -0x842(%rip), %rdi      # 0x225e
leaq 0xd0ec(%rip), %rsi      # 0xfb93
movq %rbx, %rdx
callq 0x410b
leaq -0x5a4(%rip), %rdi      # 0x2512
leaq 0xd0e0(%rip), %rsi      # 0xfb9d
movq %rbx, %rdx
callq 0x410b
leaq -0x494(%rip), %rdi      # 0x2638
leaq 0xd0d6(%rip), %rsi      # 0xfba9
movq %rbx, %rdx
callq 0x410b
leaq -0x3e5(%rip), %rdi      # 0x26fd
leaq 0xd0cc(%rip), %rsi      # 0xfbb5
movq %rbx, %rdx
callq 0x410b
leaq -0x354(%rip), %rdi      # 0x27a4
leaq 0xd0bf(%rip), %rsi      # 0xfbbe
movq %rbx, %rdx
popq %rbx
jmp 0x410b