LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/extracters/cpytap/tapeio.c
// Function: writeTapeBuffering
int writeTapeBuffering(
  FILE *handle,
  char ch
)
{
  buffer[occupied++] = ch;

  if (occupied == rLength) {
    occupied = 0;
    return WriteTapeRecord(handle, buffer, rLength);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %dl
movl 0xb4a9(%rip), %eax      # 0xda04
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xb49e(%rip)      # 0xda04
movslq %eax, %rcx
leaq 0xb4a0(%rip), %rax      # 0xda10
movb %dl, (%rax,%rcx)
movl 0xb48b(%rip), %eax      # 0xda04
cmpl 0xb481(%rip), %eax      # 0xda00
jne 0x25a6
movl $0x0, 0xb479(%rip)      # 0xda04
movq -0x10(%rbp), %rdi
movl 0xb46b(%rip), %edx      # 0xda00
leaq 0xb474(%rip), %rsi      # 0xda10
callq 0x22c0
movl %eax, -0x4(%rbp)
jmp 0x25ad
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/evilwombat[P]gopro-fw-tools/goprom.c
// Function: print_usage
static void print_usage(void)
{
	fprintf(stderr, "Usage:\n");
	fprintf(stderr, "	goprom --unpack romfs_section > unpack-romfs.sh\n");
	fprintf(stderr, "	Generate shell script to unpack a romfs section\n");
	fprintf(stderr, "\n");
	fprintf(stderr, "	goprom --update romfs_section > update-romfs.sh\n");
	fprintf(stderr, "	Generate shell script to update files in an existing romfs section\n");
	fprintf(stderr, "	DO NOT DO THIS UNLESS YOU *REALLY* KNOW WHAT YOU ARE DOING.\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2bad(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd55(%rip), %rsi       # 0x21aa
movb $0x0, %al
callq 0x1080
movq 0x2b95(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd45(%rip), %rsi       # 0x21b2
movb $0x0, %al
callq 0x1080
movq 0x2b7d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd5f(%rip), %rsi       # 0x21e4
movb $0x0, %al
callq 0x1080
movq 0x2b65(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xc14(%rip), %rsi       # 0x20b1
movb $0x0, %al
callq 0x1080
movq 0x2b4d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd61(%rip), %rsi       # 0x2216
movb $0x0, %al
callq 0x1080
movq 0x2b35(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd7b(%rip), %rsi       # 0x2248
movb $0x0, %al
callq 0x1080
movq 0x2b1d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xda8(%rip), %rsi       # 0x228d
movb $0x0, %al
callq 0x1080
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/evilwombat[P]gopro-fw-tools/goprom.c
// Function: read_word
static unsigned int read_word(FILE *fd)
{
	unsigned int r = 0;

	r |= fgetc(fd) <<  0;
	r |= fgetc(fd) <<  8;
	r |= fgetc(fd) << 16;
	r |= fgetc(fd) << 24;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
shll $0x0, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
shll $0x8, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
shll $0x10, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
shll $0x18, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jitterdebugger.c
// Function: c_states_disable
static int c_states_disable(void)
{
	uint32_t latency = 0;
	int fd;

	/* Disable on all CPUs all C states. */
	const char *cpu_dma_latency = "/dev/cpu_dma_latency";

	fd = TEMP_FAILURE_RETRY(open(cpu_dma_latency, O_RDWR | O_CLOEXEC));
	if (fd < 0) {
		if (errno == EACCES) {
			fprintf(stderr, "No permission to open %s\n", cpu_dma_latency);
		} else if (errno == ENOENT) {
			return fd;
		}
		err_handler(errno, "open()");
	}

	write(fd, &latency, sizeof(latency));

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x8(%rbp)
leaq 0x3614(%rip), %rax      # 0x6b6a
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x80002, %esi          # imm = 0x80002
movb $0x0, %al
callq 0x2310
cltq
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x20(%rbp)
movb %al, -0x29(%rbp)
jne 0x358a
callq 0x2060
cmpl $0x4, (%rax)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x355a
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x3609
callq 0x2060
cmpl $0xd, (%rax)
jne 0x35ce
movq 0x5a41(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x35ba(%rip), %rsi      # 0x6b7f
movb $0x0, %al
callq 0x2220
jmp 0x35e2
callq 0x2060
cmpl $0x2, (%rax)
jne 0x35e0
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3620
jmp 0x35e2
jmp 0x35e4
callq 0x2060
movl (%rax), %edi
leaq 0x35a7(%rip), %rsi      # 0x6b99
leaq 0x2de7(%rip), %rdx      # 0x63e0
leaq 0x35a9(%rip), %rcx      # 0x6ba9
movb $0x0, %al
callq 0x4d50
jmp 0x3609
movl -0xc(%rbp), %edi
leaq -0x8(%rbp), %rsi
movl $0x4, %edx
callq 0x20e0
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jitterdebugger.c
// Function: open_trace_fds
static void open_trace_fds(void)
{
	const char *tracing_on = "/sys/kernel/debug/tracing/tracing_on";
	const char *trace_marker = "/sys/kernel/debug/tracing/trace_marker";

	trace_fd = TEMP_FAILURE_RETRY(open(tracing_on, O_WRONLY));
	if (trace_fd < 0)
		err_handler(errno, "open()");

	tracemark_fd = TEMP_FAILURE_RETRY(open(trace_marker, O_WRONLY));
	if (tracemark_fd < 0)
		err_handler(errno, "open()");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x357b(%rip), %rax      # 0x6bba
movq %rax, -0x8(%rbp)
leaq 0x3595(%rip), %rax      # 0x6bdf
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x2310
cltq
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x18(%rbp)
movb %al, -0x31(%rbp)
jne 0x367e
callq 0x2060
cmpl $0x4, (%rax)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x364e
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, 0x5d75(%rip)      # 0x940c
cmpl $0x0, 0x5d6e(%rip)      # 0x940c
jge 0x36c7
jmp 0x36a2
callq 0x2060
movl (%rax), %edi
leaq 0x34e9(%rip), %rsi      # 0x6b99
leaq 0x2d29(%rip), %rdx      # 0x63e0
leaq 0x3548(%rip), %rcx      # 0x6c06
movb $0x0, %al
callq 0x4d50
jmp 0x36c7
jmp 0x36c9
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x2310
cltq
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x28(%rbp)
movb %al, -0x32(%rbp)
jne 0x36f9
callq 0x2060
cmpl $0x4, (%rax)
sete %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x36c9
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl %eax, 0x5cf6(%rip)      # 0x9408
cmpl $0x0, 0x5cef(%rip)      # 0x9408
jge 0x3742
jmp 0x371d
callq 0x2060
movl (%rax), %edi
leaq 0x346e(%rip), %rsi      # 0x6b99
leaq 0x2cae(%rip), %rdx      # 0x63e0
leaq 0x34cd(%rip), %rcx      # 0x6c06
movb $0x0, %al
callq 0x4d50
jmp 0x3742
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jitterdebugger.c
// Function: store_samples
static void *store_samples(void *arg)
{
	struct record_data *rec = arg;
	if (rec->fd)
		store_file(rec);
	else
		store_network(rec);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3c2a
movq -0x10(%rbp), %rdi
callq 0x45e0
jmp 0x3c33
movq -0x10(%rbp), %rdi
callq 0x46c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jitterdebugger.c
// Function: display_stats
static void *display_stats(void *arg)
{
	struct stats *s = arg;
	unsigned int i;

	for (i = 0; i < num_threads; i++)
		printf("\n");

	while (!READ_ONCE(jd_shutdown)) {
		printf(VT100_CURSOR_UP, num_threads);

		__display_stats(s);

		fflush(stdout);
		usleep(100 * 1000); /* 100 ms interval */
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x583c(%rip), %eax      # 0x94a0
jae 0x3c7f
leaq 0x2641(%rip), %rdi      # 0x62ae
movb $0x0, %al
callq 0x2140
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3c5b
jmp 0x3c81
movl 0x333d(%rip), %eax      # 0x6fc4
movl %eax, -0x18(%rbp)
movl 0x5814(%rip), %eax      # 0x94a4
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3ca8
jmp 0x3ce0
movl 0x57f2(%rip), %esi      # 0x94a0
leaq 0x3159(%rip), %rdi      # 0x6e0e
movb $0x0, %al
callq 0x2140
movq -0x10(%rbp), %rdi
callq 0x3cf0
movq 0x5304(%rip), %rax      # 0x8fd0
movq (%rax), %rdi
callq 0x22a0
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x2450
jmp 0x3c81
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jitterdebugger.c
// Function: _display_stats
static void __display_stats(struct stats *s)
{
	unsigned int i;

	for (i = 0; i < num_threads; i++) {
		printf("T:%2u (%5lu) A:%2u C:%10" PRIu64
			" Min:%10" PRIu64 " Avg:%8.2f Max:%10" PRIu64 " "
			VT100_ERASE_EOL "\n",
			i, (long)s[i].tid, s[i].affinity,
			s[i].count,
			s[i].min,
			(double) s[i].total / (double) s[i].count,
			s[i].max);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x5794(%rip), %eax      # 0x94a0
jae 0x3dae
movl -0xc(%rbp), %eax
movl %eax, %ecx
movl %ecx, %esi
movq -0x8(%rbp), %rax
leaq (%rcx,%rcx,4), %rdi
shlq $0x4, %rdi
movslq 0x8(%rax,%rdi), %rdx
movl 0xc(%rax,%rdi), %ecx
movq 0x40(%rax,%rdi), %r8
movq 0x18(%rax,%rdi), %r9
movq 0x38(%rax,%rdi), %xmm0
movaps 0x249b(%rip), %xmm3     # 0x61e0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x249f(%rip), %xmm2     # 0x61f0
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq %r8, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %edi
imulq $0x50, %rdi, %rdi
addq %rdi, %rax
movq 0x10(%rax), %rax
leaq 0x307f(%rip), %rdi      # 0x6e14
movq %rax, (%rsp)
movb $0x1, %al
callq 0x2140
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3d03
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jitterdebugger.c
// Function: ts_add
static inline struct timespec ts_add(struct timespec t1, struct timespec t2)
{
	t1.tv_sec = t1.tv_sec + t2.tv_sec;
	t1.tv_nsec = t1.tv_nsec + t2.tv_nsec;

	while (t1.tv_nsec >= NSEC_PER_SEC) {
		t1.tv_nsec -= NSEC_PER_SEC;
		t1.tv_sec++;
	}

	return t1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x3b9aca00, -0x18(%rbp) # imm = 0x3B9ACA00
jl 0x4502
movq -0x18(%rbp), %rax
subq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x44dc
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jitterdebugger.c
// Function: store_file
static void store_file(struct record_data *rec)
{
	struct stats *s = rec->stats;
	struct latency_sample sample;
	struct timespec ts;
	uint64_t val;
	unsigned int i;

	while (!READ_ONCE(jd_shutdown)) {
		for (i = 0; i < num_threads; i++) {
			sample.cpuid = i;
			while (!ringbuffer_read(s[i].rb, &ts, &val)) {
				memcpy(&sample.ts, &ts, sizeof(sample.ts));
				memcpy(&sample.val, &val, sizeof(sample.val));
				fwrite(&sample, sizeof(struct latency_sample), 1, rec->fd);
			}
		}

		usleep(DEFAULT_INTERVAL);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl 0x29c7(%rip), %eax      # 0x6fc4
movl %eax, -0x50(%rbp)
movl 0x4e9e(%rip), %eax      # 0x94a4
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4621
jmp 0x46b7
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl 0x4e6f(%rip), %eax      # 0x94a0
jae 0x46a8
movl -0x4c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl -0x4c(%rbp), %ecx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x4c50
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4666
jmp 0x469b
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
leaq -0x2c(%rbp), %rdi
movl $0x1c, %esi
movl $0x1, %edx
callq 0x23b0
jmp 0x4639
jmp 0x469d
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x4628
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x2450
jmp 0x45f7
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_work.c
// Function: start_workload
int start_workload(const char *cmd)
{
	int err;

	if (!cmd)
		return 0;

	bpid = fork();
	if (bpid > 0)
		return 0;
	if (bpid < 0)
		return errno;

	err = setpgid(0,0);
	if (err)
		err_handler(errno, "setpgid()");

	printf("start background workload: %s\n", cmd);
	err = execl("/bin/sh", "sh", "-c", cmd, (char *)0);
	if (err) {
		err_handler(err, "execl()");
		exit(EXIT_FAILURE);
	}

	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x599f
movl $0x0, -0x4(%rbp)
jmp 0x5a82
callq 0x2430
movl %eax, 0x3afe(%rip)      # 0x94a8
cmpl $0x0, 0x3af7(%rip)      # 0x94a8
jle 0x59bf
movl $0x0, -0x4(%rbp)
jmp 0x5a82
cmpl $0x0, 0x3ae2(%rip)      # 0x94a8
jge 0x59d7
callq 0x2060
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5a82
xorl %esi, %esi
movl %esi, %edi
callq 0x2390
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x5a10
jmp 0x59eb
callq 0x2060
movl (%rax), %edi
leaq 0x17b1(%rip), %rsi      # 0x71aa
leaq 0x17bd(%rip), %rdx      # 0x71bd
leaq 0x17c0(%rip), %rcx      # 0x71c7
movb $0x0, %al
callq 0x4d50
jmp 0x5a10
movq -0x10(%rbp), %rsi
leaq 0x17bb(%rip), %rdi      # 0x71d6
movb $0x0, %al
callq 0x2140
movq -0x10(%rbp), %rcx
leaq 0x17c8(%rip), %rdi      # 0x71f5
leaq 0x17c6(%rip), %rsi      # 0x71fa
leaq 0x17c2(%rip), %rdx      # 0x71fd
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x2420
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x5a7b
jmp 0x5a52
movl -0x14(%rbp), %edi
leaq 0x17a4(%rip), %rsi      # 0x7200
leaq 0x175a(%rip), %rdx      # 0x71bd
leaq 0x175d(%rip), %rcx      # 0x71c7
movb $0x0, %al
callq 0x4d50
movl $0x1, %edi
callq 0x23a0
xorl %edi, %edi
callq 0x23a0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_work.c
// Function: stop_workload
void stop_workload(void)
{
	int status;
	int err;

	if (bpid == 0)
		return;

	err = killpg(bpid, SIGTERM);
	if (err)
		err_handler(errno, "kill()");

	if (!waitpid(bpid, &status, 0))
		err_handler(errno, "waitpid()");

	err = WEXITSTATUS(status);
	if (WIFEXITED(status) && err)
		warn_handler("workload exited with %d", err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x3a09(%rip)      # 0x94a8
jne 0x5aa6
jmp 0x5b65
movl 0x39fc(%rip), %edi      # 0x94a8
movl $0xf, %esi
callq 0x22b0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x5ae6
jmp 0x5ac1
callq 0x2060
movl (%rax), %edi
leaq 0x1742(%rip), %rsi      # 0x7211
leaq 0x16e7(%rip), %rdx      # 0x71bd
leaq 0x1744(%rip), %rcx      # 0x7221
movb $0x0, %al
callq 0x4d50
jmp 0x5ae6
movl 0x39bc(%rip), %edi      # 0x94a8
leaq -0x4(%rbp), %rsi
xorl %edx, %edx
callq 0x2300
cmpl $0x0, %eax
jne 0x5b23
jmp 0x5afe
callq 0x2060
movl (%rax), %edi
leaq 0x1723(%rip), %rsi      # 0x722f
leaq 0x16aa(%rip), %rdx      # 0x71bd
leaq 0x1707(%rip), %rcx      # 0x7221
movb $0x0, %al
callq 0x4d50
jmp 0x5b23
movl -0x4(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x5b65
cmpl $0x0, -0x8(%rbp)
je 0x5b65
jmp 0x5b44
movl -0x8(%rbp), %ecx
leaq 0x16f4(%rip), %rdi      # 0x7242
leaq 0x1668(%rip), %rsi      # 0x71bd
leaq 0x16c5(%rip), %rdx      # 0x7221
movb $0x0, %al
callq 0x4e40
jmp 0x5b65
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_sysinfo.c
// Function: collect_system_info
struct system_info *collect_system_info(void)
{
	struct system_info *info;
	struct utsname buf;
	int err;

	info = malloc(sizeof(*info));
	if (!info)
		err_handler(errno, "malloc()");

	err = uname(&buf);
	if (err)
		err_handler(errno, "Could not retrieve name and information about current kernel");

	info->sysname = jd_strdup(buf.sysname);
	info->nodename = jd_strdup(buf.nodename);
	info->release = jd_strdup(buf.release);
	info->version = jd_strdup(buf.version);
	info->machine = jd_strdup(buf.machine);

	info->cpus_online = get_nprocs();

	return info;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movl $0x30, %edi
callq 0x2290
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5bb7
jmp 0x5b92
callq 0x2060
movl (%rax), %edi
leaq 0x8bd(%rip), %rsi       # 0x645d
leaq 0x16bd(%rip), %rdx      # 0x7264
leaq 0x16c3(%rip), %rcx      # 0x7271
movb $0x0, %al
callq 0x4d50
jmp 0x5bb7
leaq -0x18e(%rbp), %rdi
callq 0x2160
movl %eax, -0x194(%rbp)
cmpl $0x0, -0x194(%rbp)
je 0x5bf9
jmp 0x5bd4
callq 0x2060
movl (%rax), %edi
leaq 0x16a3(%rip), %rsi      # 0x7285
leaq 0x167b(%rip), %rdx      # 0x7264
leaq 0x1681(%rip), %rcx      # 0x7271
movb $0x0, %al
callq 0x4d50
jmp 0x5bf9
leaq -0x18e(%rbp), %rdi
callq 0x5720
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x18e(%rbp), %rdi
addq $0x41, %rdi
callq 0x5720
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq -0x18e(%rbp), %rdi
addq $0x82, %rdi
callq 0x5720
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq -0x18e(%rbp), %rdi
addq $0xc3, %rdi
callq 0x5720
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq -0x18e(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
callq 0x5720
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
callq 0x2440
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/igaw[P]jitterdebugger/jd_sysinfo.c
// Function: free_system_info
void free_system_info(struct system_info *sysinfo)
{
	if (sysinfo->sysname)
		free(sysinfo->sysname);
	if (sysinfo->nodename)
		free(sysinfo->nodename);
	if (sysinfo->release)
		free(sysinfo->release);
	if (sysinfo->version)
		free(sysinfo->version);
	if (sysinfo->machine)
		free(sysinfo->machine);
	free(sysinfo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5ed2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5eea
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5f02
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x5f1a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x5f32
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/blowfish_gen.c
// Function: modpow
uint32_t modpow(uint32_t b, uint32_t e, uint32_t m)
{
  uint32_t x = 1;

  while (e > 0) {
    if (e % 2 == 0) {
      b = (uint64_t)b*b % m;
      e /= 2;
    }
    else {
      x = (uint64_t)b * x % m;
      e -= 1;
    }
  }
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jbe 0x11c8
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x11a6
movl -0x4(%rbp), %eax
movl -0x4(%rbp), %ecx
imulq %rcx, %rax
movl -0xc(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x8(%rbp)
jmp 0x11c6
movl -0x4(%rbp), %eax
movl -0x10(%rbp), %ecx
imulq %rcx, %rax
movl -0xc(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1174
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/blowfish_gen.c
// Function: s
double s(int n, int j)
{
  int k;
  double x = 0.0;

  for (k=0; k <= n; k++) {
    x += (double)modpow(16, n-k, 8*k+j) / (8*k+j);
    if (x > 1.0) x -= 1.0;
  }

  double d = 1.0;
  double x0 = -1.0;
  for (; x - x0 > 1e-12; k++) {
    x0 = x;
    d /= 16;
    x += d / (8.0*k+j);
  }

  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x1269
movl -0x4(%rbp), %esi
movl -0xc(%rbp), %eax
subl %eax, %esi
movl -0x8(%rbp), %edx
movl %eax, %ecx
movl %edx, %eax
leal (%rax,%rcx,8), %edx
movl $0x10, %edi
callq 0x1160
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movl -0xc(%rbp), %eax
shll $0x3, %eax
addl -0x8(%rbp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0xdd0(%rip), %xmm1      # 0x2010
ucomisd %xmm1, %xmm0
jbe 0x125c
movsd -0x18(%rbp), %xmm0
movsd 0xdbd(%rip), %xmm1      # 0x2010
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x125e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11ed
movsd 0xd9f(%rip), %xmm0      # 0x2010
movsd %xmm0, -0x20(%rbp)
movsd 0xd8a(%rip), %xmm0      # 0x2008
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd 0xd83(%rip), %xmm1      # 0x2018
ucomisd %xmm1, %xmm0
jbe 0x12f3
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0xd76(%rip), %xmm1      # 0x2028
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
cvtsi2sdl -0x8(%rbp), %xmm2
movsd 0xd4e(%rip), %xmm3      # 0x2020
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1283
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/blowfish_gen.c
// Function: pi_digit16
int pi_digit16(int n)
{
  double d = 16*(4*s(n,1) - 2*s(n,4) - s(n,5) - s(n,6));
  if (d < 0) d -= 1.0;

  ticks += 100ul*(n+1);
  if (ticks >= TICKS_PER_PERCENT) {
    ticks -= TICKS_PER_PERCENT;
    fprintf(stderr, "%d%%\r", ++percent);
    fflush(stderr);
  }

  return (unsigned)(int)d % 16;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %esi
callq 0x11d0
movsd %xmm0, -0x28(%rbp)
movl -0x4(%rbp), %edi
movl $0x4, %esi
callq 0x11d0
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movsd 0xcfe(%rip), %xmm1      # 0x2038
mulsd %xmm2, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0xcd3(%rip), %xmm2      # 0x2030
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x4(%rbp), %edi
movl $0x5, %esi
callq 0x11d0
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x4(%rbp), %edi
movl $0x6, %esi
callq 0x11d0
movsd -0x18(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd 0xc82(%rip), %xmm0      # 0x2028
mulsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x13cf
movsd -0x10(%rbp), %xmm0
movsd 0xc4a(%rip), %xmm1      # 0x2010
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
cltq
imulq $0x64, %rax, %rax
addq 0x2c66(%rip), %rax      # 0x4048
movq %rax, 0x2c5f(%rip)      # 0x4048
cmpq $0x21238c8, 0x2c54(%rip) # imm = 0x21238C8
jb 0x1440
movq 0x2c4b(%rip), %rax      # 0x4048
subq $0x21238c8, %rax        # imm = 0x21238C8
movq %rax, 0x2c3e(%rip)      # 0x4048
movq 0x2be7(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl 0x2c36(%rip), %edx      # 0x4050
addl $0x1, %edx
movl %edx, 0x2c2d(%rip)      # 0x4050
leaq 0xc16(%rip), %rsi       # 0x2040
movb $0x0, %al
callq 0x1040
movq 0x2bc0(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
callq 0x1050
cvttsd2si -0x10(%rbp), %eax
andl $0xf, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/blowfish_gen.c
// Function: print_constants
void print_constants(int *digi, int n, int indent)
{
  int i, j;
  uint32_t x;

  for (i=0; i<n; i++) {
    if (i % 4 == 0) {
      if (i > 0)
        printf(",\n");
      printf("%*c", indent, ' ');
    }
    else
      printf(", ");
    for (x=0, j=0; j<8; j++)
      x = 16*x + pi_digit16((*digi)++);
    printf("0x%.8Xul", x);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1522
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x14b1
cmpl $0x0, -0x14(%rbp)
jle 0x1499
leaq 0xbb4(%rip), %rdi       # 0x2046
movb $0x0, %al
callq 0x1030
movl -0x10(%rbp), %esi
leaq 0xba6(%rip), %rdi       # 0x2049
movl $0x20, %edx
movb $0x0, %al
callq 0x1030
jmp 0x14bf
leaq 0xb95(%rip), %rdi       # 0x204d
movb $0x0, %al
callq 0x1030
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x1503
movl -0x1c(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movl %edi, %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
callq 0x1300
movl %eax, %ecx
movl -0x20(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x14cd
movl -0x1c(%rbp), %esi
leaq 0xb43(%rip), %rdi       # 0x2050
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1469
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/blowfish_gen.c
// Function: main
int main(void)
{
  int n = 0;
  int i;

  printf(
    "/* initial subkeys and S-boxes for Blowfish\n"
    "   generated by blowfish_gen.c */\n"
    "static const uint32_t P0[18] = {\n");
  print_constants(&n, 18, 2);
  printf(
    "\n};\n"
    "static const uint32_t S0[4][256] = {\n");
  for (i=0; i<4; i++) {
    printf("  {\n");
    print_constants(&n, 256, 4);
    printf("\n  }%s\n", (i < 3) ? "," : "");
  }
  printf("};\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
leaq 0xb0c(%rip), %rdi       # 0x2059
movb $0x0, %al
callq 0x1030
leaq -0x8(%rbp), %rdi
movl $0x12, %esi
movl $0x2, %edx
callq 0x1450
leaq 0xb5b(%rip), %rdi       # 0x20c9
movb $0x0, %al
callq 0x1030
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x15d4
leaq 0xb6a(%rip), %rdi       # 0x20f3
movb $0x0, %al
callq 0x1030
leaq -0x8(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x4, %edx
callq 0x1450
movl -0xc(%rbp), %ecx
leaq 0xa9b(%rip), %rsi       # 0x2048
leaq 0xb4c(%rip), %rax       # 0x2100
cmpl $0x3, %ecx
cmovlq %rax, %rsi
leaq 0xb36(%rip), %rdi       # 0x20f8
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x157c
leaq 0xb27(%rip), %rdi       # 0x2102
movb $0x0, %al
callq 0x1030
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_03/cross_referencer.c
// Function: main
int main(void)
{
  size_t line_number = 1;
  char word[MAX_WORD_LEN];
  struct tree_node *tree_root = NULL;

  while (get_word(word, MAX_WORD_LEN) != EOF)
  {
    if (word[0] == '\n')
    {
      ++line_number;
    }
    else if (isalpha(word[0]))
    {
      if (bin_search(word, linking_words, NR_OF_LINKING_WORDS) == -1)
      {
        tree_root = add_to_tree(tree_root, word, line_number);
      }
    }
  }

  print_tree(tree_root);

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movq $0x1, -0x10(%rbp)
movq $0x0, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
movl $0x64, %esi
callq 0x1290
cmpl $-0x1, %eax
je 0x126a
movsbl -0x80(%rbp), %eax
cmpl $0xa, %eax
jne 0x120f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1265
callq 0x10b0
movq (%rax), %rax
movsbl -0x80(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x1263
leaq -0x80(%rbp), %rdi
leaq 0x2e39(%rip), %rsi      # 0x4070
movl $0x1a, %edx
callq 0x13c0
cmpl $-0x1, %eax
jne 0x1261
movq -0x88(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1460
movq %rax, -0x88(%rbp)
jmp 0x1263
jmp 0x1265
jmp 0x11e5
movq -0x88(%rbp), %rdi
callq 0x1570
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_03/cross_referencer.c
// Function: add_to_tree
struct tree_node *add_to_tree(struct tree_node *node_p, char *word, size_t line_number)
{
  int cond;

  if (node_p == NULL)
  {
    node_p = (struct tree_node *)malloc(sizeof(struct tree_node));
    node_p->line_numbers = add_to_list(node_p->line_numbers, line_number);
    node_p->word = str_dup(word);
    node_p->left = node_p->right = NULL;
  }
  else if ((cond = strcmp(word, node_p->word)) == 0)
  {
    node_p->line_numbers = add_to_list(node_p->line_numbers, line_number);
  }
  else if (cond < 0)
  {
    node_p->left = add_to_tree(node_p->left, word, line_number);
  }
  else if (cond > 0)
  {
    node_p->right = add_to_tree(node_p->right, word, line_number);
  }

  return node_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x14d5
movl $0x20, %edi
callq 0x1080
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1680
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x15d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x155f
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x1070
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jne 0x150b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1680
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x155d
cmpl $0x0, -0x1c(%rbp)
jge 0x1533
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1460
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x155b
cmpl $0x0, -0x1c(%rbp)
jle 0x1559
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1460
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x155b
jmp 0x155d
jmp 0x155f
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_03/cross_referencer.c
// Function: print_tree
void print_tree(struct tree_node *node_p)
{
  if (node_p != NULL)
  {
    print_tree(node_p->left);
    printf("%s: ", node_p->word);
    print_list(node_p->line_numbers);
    putchar('\n');
    print_tree(node_p->right);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15c9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1570
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0xac7(%rip), %rdi       # 0x2065
movb $0x0, %al
callq 0x1060
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x16f0
movl $0xa, %edi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1570
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_03/cross_referencer.c
// Function: add_to_list
struct list_node *add_to_list(struct list_node *list_node_p, size_t line_number)
{
  if (list_node_p == NULL)
  {
    list_node_p = (struct list_node *)malloc(sizeof(struct list_node));
    list_node_p->line_number = line_number;
    list_node_p->next = NULL;
  }
  else
  {
    list_node_p->next = add_to_list(list_node_p->next, line_number);
  }

  return list_node_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x16be
movl $0x10, %edi
callq 0x1080
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x16da
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1680
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_03/cross_referencer.c
// Function: print_list
void print_list(struct list_node *node_p)
{
  static enum boolean first = TRUE;
  if (node_p != NULL)
  {
    if (first)
    {
      first = FALSE;
      printf("%zu", node_p->line_number);
    }
    else
    {
      printf(", %zu", node_p->line_number);
    }

    print_list(node_p->next);
  }
  else
  {
    first = TRUE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1751
cmpl $0x0, 0x2a36(%rip)      # 0x4140
je 0x172d
movl $0x0, 0x2a2a(%rip)      # 0x4140
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x948(%rip), %rdi       # 0x206c
movb $0x0, %al
callq 0x1060
jmp 0x1742
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x92f(%rip), %rdi       # 0x206a
movb $0x0, %al
callq 0x1060
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x16f0
jmp 0x175b
movl $0x1, 0x29e5(%rip)      # 0x4140
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/juicer.c
// Function: assembly_scale_max_seq
uint64_t assembly_scale_max_seq(asm_dict_t *dict, int *scale, uint64_t max_s, uint64_t *g)
{
    uint32_t i;
    uint64_t s;
    sd_aseq_t seq;
 
    s = 0;
    for (i = 0; i < dict->n; ++i) {
        seq = dict->s[i];
        s = MAX(s, seq.len + seq.gap);
    }
    
    *g = s;

    return linear_scale(s, scale, max_s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xcbcb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x24(%rbp), %eax
imulq $0x58, %rax, %rax
addq %rax, %rsi
leaq -0x88(%rbp), %rdi
movl $0x58, %edx
callq 0x2250
movq -0x30(%rbp), %rax
movq -0x80(%rbp), %rcx
addq -0x78(%rbp), %rcx
cmpq %rcx, %rax
jbe 0xcba6
movq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0xcbb5
movq -0x80(%rbp), %rax
addq -0x78(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xcb5a
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2a20
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/juicer.c
// Function: main
int main(int argc, char *argv[])
{
    if (argc == 1)
        return usage(stderr);
    if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0)
        return usage(stdout);
    if (strcmp(argv[1], "-V") == 0 || strcmp(argv[1], "--version") == 0) {
        puts(JUICER_VERSION);
        return 0;
    }
    if (strcmp(argv[1], "pre") == 0)
        return main_pre(argc - 1, argv + 1);
    if (strcmp(argv[1], "post") == 0)
        return main_post(argc - 1, argv + 1);
    fprintf(stderr, "[E::%s] unrecognized command '%s'. Abort!\n", __func__, argv[1]);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0xcc23
movq 0xb3e5(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
callq 0xcd50
movl %eax, -0x4(%rbp)
jmp 0xcd46
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7286(%rip), %rsi      # 0x13eb8
callq 0x2210
cmpl $0x0, %eax
je 0xcc55
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7270(%rip), %rsi      # 0x13ebb
callq 0x2210
cmpl $0x0, %eax
jne 0xcc6c
movq 0xb374(%rip), %rax      # 0x17fd0
movq (%rax), %rdi
callq 0xcd50
movl %eax, -0x4(%rbp)
jmp 0xcd46
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7247(%rip), %rsi      # 0x13ec2
callq 0x2210
cmpl $0x0, %eax
je 0xcc9e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7231(%rip), %rsi      # 0x13ec5
callq 0x2210
cmpl $0x0, %eax
jne 0xccb6
leaq 0x722a(%rip), %rdi      # 0x13ecf
callq 0x20c0
movl $0x0, -0x4(%rbp)
jmp 0xcd46
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x733b(%rip), %rsi      # 0x14000
callq 0x2210
cmpl $0x0, %eax
jne 0xcce7
movl -0x8(%rbp), %edi
subl $0x1, %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xcdf0
movl %eax, -0x4(%rbp)
jmp 0xcd46
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7d2e(%rip), %rsi      # 0x14a24
callq 0x2210
cmpl $0x0, %eax
jne 0xcd18
movl -0x8(%rbp), %edi
subl $0x1, %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xdc10
movl %eax, -0x4(%rbp)
jmp 0xcd46
movq 0xb2d9(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x71a4(%rip), %rsi      # 0x13ed5
leaq 0x71c8(%rip), %rdx      # 0x13f00
movb $0x0, %al
callq 0x2230
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/juicer.c
// Function: usage
static int usage(FILE *fo)
{
    fprintf(fo, "\n");
    fprintf(fo, "Usage:   juicer <command> <arguments>\n");
    fprintf(fo, "Version: %s\n\n", JUICER_VERSION);
    fprintf(fo, "Command: pre       generate files compatible with Juicebox toolset\n");
    fprintf(fo, "         post      generate assembly files after Juicebox curation\n");
    fprintf(fo, "\n");
    return fo == stdout? 0 : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x71d1(%rip), %rsi      # 0x13f38
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x718c(%rip), %rsi      # 0x13f05
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x71a1(%rip), %rsi      # 0x13f2c
leaq 0x713d(%rip), %rdx      # 0x13ecf
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x7196(%rip), %rsi      # 0x13f3a
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x71c8(%rip), %rsi      # 0x13f7e
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x7170(%rip), %rsi      # 0x13f38
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdx
movq 0xb1f6(%rip), %rax      # 0x17fd0
movq (%rax), %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/juicer.c
// Function: print_help_pre
static void print_help_pre(FILE *fp_help)
{
    fprintf(fp_help, "Usage: juicer pre [options] <hic.bed>|<hic.bam>|<hic.pa5>|<hic.bin> <scaffolds.agp> <contigs.fa.fai>\n");
    fprintf(fp_help, "Options:\n");
    fprintf(fp_help, "    -a                preprocess for assembly mode\n");
    fprintf(fp_help, "    -q INT            minimum mapping quality [10]\n");
    fprintf(fp_help, "    -o STR            output file prefix (required for '-a' mode) [stdout]\n");
    fprintf(fp_help, "    --file-type STR   input file type BED|BAM|PA5|BIN, file name extension is ignored if set\n");
    fprintf(fp_help, "    --version         show version number\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x5b51(%rip), %rsi      # 0x144a8
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x5ba5(%rip), %rsi      # 0x1450e
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x5b9d(%rip), %rsi      # 0x14518
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x5bbf(%rip), %rsi      # 0x1454c
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x5be1(%rip), %rsi      # 0x14580
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x5c1b(%rip), %rsi      # 0x145cc
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x5c67(%rip), %rsi      # 0x1462a
movb $0x0, %al
callq 0x2230
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/juicer.c
// Function: parse_bam_rec
static char *parse_bam_rec(bam1_t *b, bam_header_t *h, uint8_t q, int32_t *s, int32_t *e, char **cname)
{
    // 0x4 0x100 0x200 0x400 0x800
    if ((b->core.flag & 0xF04) || (!b->core.flag) || b->core.qual < q)
        return 0;
    *cname = h->target_name[b->core.tid];
    *s = b->core.pos;
    *e = get_target_end(b);

    return strdup(bam1_qname(b));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
andl $0xf04, %eax            # imm = 0xF04
cmpl $0x0, %eax
jne 0x1122e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
cmpl $0x0, %eax
je 0x1122e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x10, %rax
andq $0xff, %rax
movzbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jge 0x11238
movq $0x0, -0x8(%rbp)
jmp 0x11281
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x4040
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2430
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/juicer.c
// Function: parse_bam_rec1
static int parse_bam_rec1(bam1_t *b, bam_header_t *h, char **cname0, int32_t *s0, char **cname1, int32_t *s1)
{
    // 0x4 0x8 0x40 0x100 0x200 0x400 0x800
    if ((b->core.flag & 0xF4C) || (!b->core.flag))
        return 1;
    *cname0 = h->target_name[b->core.tid];
    *s0 = b->core.pos;
    *cname1 = h->target_name[b->core.mtid];
    *s1 = b->core.mpos;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
andl $0xf4c, %eax            # imm = 0xF4C
cmpl $0x0, %eax
jne 0x1163f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
cmpl $0x0, %eax
jne 0x11648
movl $0x1, -0x4(%rbp)
jmp 0x1169e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x14(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/juicer.c
// Function: print_help_post
static void print_help_post(FILE *fp_help)
{
    fprintf(fp_help, "Usage: juicer post [options] <review.assembly> <liftover.agp> <contigs.fa[.fai]>\n");
    fprintf(fp_help, "Options:\n");
    fprintf(fp_help, "    -o STR            output file prefix (required for scaffolds FASTA output) [stdout]\n");
    fprintf(fp_help, "    --seq-ctype STR   AGP output sequence component type [%s]\n", agp_component_type_val(DEFAULT_AGP_SEQ_COMPONENT_TYPE));
    fprintf(fp_help, "    --gap-ctype STR   AGP output gap component type [%s]\n", agp_component_type_val(DEFAULT_AGP_GAP_COMPONENT_TYPE));
    fprintf(fp_help, "    --gap-link  STR   AGP output gap linkage evidence [%s]\n", agp_linkage_evidence_val(DEFAULT_AGP_LINKAGE_EVIDENCE));
    fprintf(fp_help, "    --gap-size  INT   AGP output gap size between sequence component [%d]\n", DEFAULT_AGP_GAP_SIZE);
    fprintf(fp_help, "    --version         show version number\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2b88(%rip), %rsi      # 0x14aaf
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x25d5(%rip), %rsi      # 0x1450e
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x2bb6(%rip), %rsi      # 0x14b01
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x62ff(%rip), %rax      # 0x18260
movl (%rax), %edi
callq 0x10f50
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x2be4(%rip), %rsi      # 0x14b5a
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x62d8(%rip), %rax      # 0x18264
movl (%rax), %edi
callq 0x10f50
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x2bf8(%rip), %rsi      # 0x14b99
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x62b5(%rip), %rax      # 0x1826c
movl (%rax), %edi
callq 0x12aa0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x2c07(%rip), %rsi      # 0x14bd3
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x6292(%rip), %rax      # 0x18270
movl (%rax), %edx
leaq 0x2c28(%rip), %rsi      # 0x14c0f
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0x2631(%rip), %rsi      # 0x1462a
movb $0x0, %al
callq 0x2230
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arkanis[P]process-map/./deps/raygui.h
// Function: GuiSetFont
void GuiSetFont(Font font)
{
    if (font.texture.id > 0)
    {
        // NOTE: If we try to setup a font but default style has not been
        // lazily loaded before, it will be overwritten, so we need to force
        // default style loading first
        if (!guiStyleLoaded) GuiLoadStyleDefault();

        guiFont = font;
        GuiSetStyle(DEFAULT, TEXT_SIZE, font.baseSize);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpl $0x0, 0xc(%rax)
jbe 0x6a0b
testb $0x1, 0xc3708(%rip)     # 0xca0e5
jne 0x69e4
callq 0x6a20
movq -0x8(%rbp), %rsi
leaq 0xc36f9(%rip), %rdi     # 0xca0e8
movl $0x30, %edx
callq 0x6790
movq -0x8(%rbp), %rax
movl (%rax), %edx
xorl %edi, %edi
movl $0x10, %esi
callq 0x6ee0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)