LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/igaw[P]jitterdebugger/jitterdebugger.c
// Function: usage
static void __attribute__((noreturn)) usage(int status)
{
	printf("jitterdebugger [options]\n");
	printf("\n");
	printf("General usage:\n");
	printf("  -h, --help            Print this help\n");
	printf("  -v, --verbose         Print live statistics\n");
	printf("      --version         Print version of jitterdebugger\n");
	printf("  -o, --output DIR      Store collected data into DIR\n");
	printf("  -c, --command CMD	Execute CMD (workload) in background\n");
	printf("\n");
	printf("Sampling:\n");
	printf("  -l, --loops VALUE     Max number of measurements\n");
	printf("  -D, --duration TIME   Specify a length for the test run.\n");
	printf("                        Append 'm', 'h', or 'd' to specify minutes, hours or days.\n");
	printf("  -b, --break VALUE     Stop if max latency exceeds VALUE.\n");
	printf("                        Also the tracers\n");
	printf("  -N, --nsec            Meassurement in nano seconds\n");
	printf("  -i, --interval TIME   Sleep interval for sampling threads in microseconds\n");
	printf("                        or nano seconds (see -N/--nsec)\n");
	printf("  -n			Send samples to host:port\n");
	printf("  -s			Store samples into --output DIR\n");
	printf("\n");
	printf("Threads: \n");
	printf("  -a, --affinity CPUSET Core affinity specification\n");
	printf("                        e.g. 0,2,5-7 starts a thread on first, third and last two\n");
	printf("                        cores on a 8-core system.\n");
	printf("                        May also be set in hexadecimal with '0x' prefix\n");
	printf("  -p, --priority PRI    Worker thread priority. [1..98]\n");

	exit(status);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x2335(%rip), %rdi      # 0x59c1
callq 0x20a0
pushq $0xa
popq %rbp
movl %ebp, %edi
callq 0x2050
leaq 0x2338(%rip), %rdi      # 0x59da
callq 0x20a0
leaq 0x233b(%rip), %rdi      # 0x59e9
callq 0x20a0
leaq 0x2357(%rip), %rdi      # 0x5a11
callq 0x20a0
leaq 0x2379(%rip), %rdi      # 0x5a3f
callq 0x20a0
leaq 0x23a5(%rip), %rdi      # 0x5a77
callq 0x20a0
leaq 0x23cf(%rip), %rdi      # 0x5aad
callq 0x20a0
movl %ebp, %edi
callq 0x2050
leaq 0x23f5(%rip), %rdi      # 0x5ae6
callq 0x20a0
leaq 0x23f3(%rip), %rdi      # 0x5af0
callq 0x20a0
leaq 0x241a(%rip), %rdi      # 0x5b23
callq 0x20a0
leaq 0x2449(%rip), %rdi      # 0x5b5e
callq 0x20a0
leaq 0x2490(%rip), %rdi      # 0x5bb1
callq 0x20a0
leaq 0x24bf(%rip), %rdi      # 0x5bec
callq 0x20a0
leaq 0x24dc(%rip), %rdi      # 0x5c15
callq 0x20a0
leaq 0x2505(%rip), %rdi      # 0x5c4a
callq 0x20a0
leaq 0x2545(%rip), %rdi      # 0x5c96
callq 0x20a0
leaq 0x2571(%rip), %rdi      # 0x5cce
callq 0x20a0
leaq 0x2586(%rip), %rdi      # 0x5cef
callq 0x20a0
movl %ebp, %edi
callq 0x2050
leaq 0x259a(%rip), %rdi      # 0x5d16
callq 0x20a0
leaq 0x2598(%rip), %rdi      # 0x5d20
callq 0x20a0
leaq 0x25c0(%rip), %rdi      # 0x5d54
callq 0x20a0
leaq 0x2606(%rip), %rdi      # 0x5da6
callq 0x20a0
leaq 0x262c(%rip), %rdi      # 0x5dd8
callq 0x20a0
leaq 0x2668(%rip), %rdi      # 0x5e20
callq 0x20a0
movl %ebx, %edi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0xa
popq %rbp
cmpl 0x4a0c(%rip), %r14d     # 0x84b0
jae 0x3ab2
movl %ebp, %edi
callq 0x2050
incl %r14d
jmp 0x3a9d
leaq 0x1d28(%rip), %r14      # 0x57e1
movq 0x4510(%rip), %r15      # 0x7fd0
cmpl $0x0, 0x49ed(%rip)      # 0x84b4
jne 0x3af5
movl 0x49e1(%rip), %esi      # 0x84b0
movq %r14, %rdi
xorl %eax, %eax
callq 0x2150
movq %rbx, %rdi
callq 0x3b02
movq (%r15), %rdi
callq 0x22b0
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x2460
jmp 0x3ac0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x8, %rbx
xorl %r14d, %r14d
leaq 0x1ccb(%rip), %r15      # 0x57e7
movl 0x498e(%rip), %eax      # 0x84b0
cmpq %rax, %r14
jae 0x3b91
movslq (%rbx), %rdx
movl 0x4(%rbx), %ecx
movq 0x10(%rbx), %r9
movdqu 0x30(%rbx), %xmm0
movdqa %xmm0, %xmm1
pand 0x14ce(%rip), %xmm1     # 0x5010
por 0x14d6(%rip), %xmm1     # 0x5020
psrlq $0x20, %xmm0
por 0x14d9(%rip), %xmm0     # 0x5030
subpd 0x14e1(%rip), %xmm0     # 0x5040
addpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
divsd %xmm1, %xmm0
movq 0x8(%rbx), %rax
movq 0x38(%rbx), %r8
movq %rax, (%rsp)
movq %r15, %rdi
movl %r14d, %esi
movb $0x1, %al
callq 0x2150
incq %r14
addq $0x50, %rbx
jmp 0x3b1c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x466d
movq %rdi, %rbx
callq 0x2440
movl %eax, 0x3e58(%rip)      # 0x84b8
testl %eax, %eax
jg 0x466d
jns 0x4676
callq 0x2070
movl (%rax), %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %edi, %edi
xorl %esi, %esi
callq 0x23a0
testl %eax, %eax
je 0x46a6
callq 0x2070
movl (%rax), %edi
leaq 0x18e6(%rip), %rsi      # 0x5f77
leaq 0x18f2(%rip), %rdx      # 0x5f8a
leaq 0x18f5(%rip), %rcx      # 0x5f94
xorl %eax, %eax
callq 0x3ee1
leaq 0x18f6(%rip), %rdi      # 0x5fa3
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2150
leaq 0x1904(%rip), %rdi      # 0x5fc2
leaq 0x1902(%rip), %rsi      # 0x5fc7
leaq 0x18fe(%rip), %rdx      # 0x5fca
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x2430
testl %eax, %eax
jne 0x46e4
xorl %edi, %edi
callq 0x23b0
leaq 0x18e2(%rip), %rsi      # 0x5fcd
leaq 0x1898(%rip), %rdx      # 0x5f8a
leaq 0x189b(%rip), %rcx      # 0x5f94
movl %eax, %edi
xorl %eax, %eax
callq 0x3ee1
pushq $0x1
popq %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x3da8(%rip), %edi      # 0x84b8
testl %edi, %edi
je 0x47bc
pushq %rax
pushq $0xf
popq %rsi
callq 0x22c0
testl %eax, %eax
je 0x4748
callq 0x2070
movl (%rax), %edi
leaq 0x18ab(%rip), %rsi      # 0x5fde
leaq 0x1850(%rip), %rdx      # 0x5f8a
leaq 0x18ad(%rip), %rcx      # 0x5fee
xorl %eax, %eax
callq 0x3ee1
movl 0x3d6a(%rip), %edi      # 0x84b8
leaq 0x4(%rsp), %rsi
xorl %edx, %edx
callq 0x2310
testl %eax, %eax
jne 0x4781
callq 0x2070
movl (%rax), %edi
leaq 0x1890(%rip), %rsi      # 0x5ffc
leaq 0x1817(%rip), %rdx      # 0x5f8a
leaq 0x1874(%rip), %rcx      # 0x5fee
xorl %eax, %eax
callq 0x3ee1
movl 0x4(%rsp), %eax
movl %eax, %ecx
shrl $0x8, %ecx
testb $0x7f, %al
setne %al
andl $0xff, %ecx
sete %dl
orb %al, %dl
jne 0x47b8
leaq 0x186c(%rip), %rdi      # 0x600f
leaq 0x17e0(%rip), %rsi      # 0x5f8a
leaq 0x183d(%rip), %rdx      # 0x5fee
xorl %eax, %eax
callq 0x3fae
addq $0x8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x190, %rsp            # imm = 0x190
pushq $0x30
popq %rdi
callq 0x22a0
movq %rax, %rbx
testq %rax, %rax
jne 0x47fb
callq 0x2070
movl (%rax), %edi
leaq 0xafe(%rip), %rsi       # 0x52e4
leaq 0x1844(%rip), %rdx      # 0x6031
leaq 0x184a(%rip), %rcx      # 0x603e
xorl %eax, %eax
callq 0x3ee1
leaq 0xa(%rsp), %rdi
callq 0x2170
testl %eax, %eax
je 0x482c
callq 0x2070
movl (%rax), %edi
leaq 0x183b(%rip), %rsi      # 0x6052
leaq 0x1813(%rip), %rdx      # 0x6031
leaq 0x1819(%rip), %rcx      # 0x603e
xorl %eax, %eax
callq 0x3ee1
leaq 0xa(%rsp), %rdi
callq 0x4481
movq %rax, (%rbx)
leaq 0x4b(%rsp), %rdi
callq 0x4481
movq %rax, 0x8(%rbx)
leaq 0x8c(%rsp), %rdi
callq 0x4481
movq %rax, 0x10(%rbx)
leaq 0xcd(%rsp), %rdi
callq 0x4481
movq %rax, 0x18(%rbx)
leaq 0x10e(%rsp), %rdi
callq 0x4481
movq %rax, 0x20(%rbx)
callq 0x2450
movl %eax, 0x28(%rbx)
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2040
movq 0x8(%rbx), %rdi
callq 0x2040
movq 0x10(%rbx), %rdi
callq 0x2040
movq 0x18(%rbx), %rdi
callq 0x2040
movq 0x20(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edx, %r8d
pushq $0x1
popq %rcx
movl %edi, %edi
movl %esi, %r9d
subl $0x1, %r9d
jb 0x11a9
testb $0x1, %sil
je 0x1196
movl %ecx, %eax
imulq %rdi, %rax
xorl %edx, %edx
divq %r8
movl %r9d, %esi
movq %rdx, %rcx
jmp 0x1177
imulq %rdi, %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movq %rdx, %rdi
shrl %esi
jmp 0x1172
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %ebp
xorpd %xmm5, %xmm5
xorl %r13d, %r13d
pushq $0x10
popq %r14
movsd 0xe37(%rip), %xmm0      # 0x2008
movsd 0xe37(%rip), %xmm7      # 0x2010
movl %edi, %r15d
movl %esi, %r12d
cmpl %ebp, %r13d
jg 0x124d
movl %r14d, %edi
movl %r15d, %esi
movl %r12d, %edx
movapd %xmm5, (%rsp)
callq 0x116c
movsd 0xe11(%rip), %xmm7      # 0x2010
movsd 0xe01(%rip), %xmm0      # 0x2008
movl %eax, %eax
cvtsi2sd %rax, %xmm2
cvtsi2sd %r12d, %xmm1
divsd %xmm1, %xmm2
movapd (%rsp), %xmm3
addsd %xmm2, %xmm3
movapd %xmm3, %xmm2
addsd %xmm0, %xmm2
movapd %xmm7, %xmm1
cmpltsd %xmm3, %xmm1
andpd %xmm1, %xmm2
andnpd %xmm3, %xmm1
orpd %xmm2, %xmm1
incl %r13d
addl $0x8, %r12d
decl %r15d
movapd %xmm1, %xmm5
jmp 0x11df
cvtsi2sd %ebx, %xmm6
movsd 0xdbf(%rip), %xmm1      # 0x2018
movsd 0xdbf(%rip), %xmm2      # 0x2020
movsd 0xdbf(%rip), %xmm3      # 0x2028
movapd %xmm0, %xmm4
movapd %xmm5, %xmm0
subsd %xmm4, %xmm5
ucomisd %xmm1, %xmm5
jbe 0x129d
mulsd %xmm2, %xmm7
cvtsi2sd %r13d, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm6, %xmm4
movapd %xmm7, %xmm5
divsd %xmm4, %xmm5
addsd %xmm0, %xmm5
incl %r13d
jmp 0x1269
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movl %edi, %ebx
pushq $0x1
popq %rsi
callq 0x11ac
movapd %xmm0, 0x20(%rsp)
pushq $0x4
popq %rsi
movl %ebx, %edi
callq 0x11ac
movsd %xmm0, 0x18(%rsp)
pushq $0x5
popq %rsi
movl %ebx, %edi
callq 0x11ac
movsd %xmm0, 0x10(%rsp)
pushq $0x6
popq %rsi
movl %ebx, %edi
callq 0x11ac
incl %ebx
movslq %ebx, %rax
imulq $0x64, %rax, %rax
addq 0x2d55(%rip), %rax      # 0x4050
movq %rax, 0x2d4e(%rip)      # 0x4050
cmpq $0x21238c8, %rax        # imm = 0x21238C8
jae 0x136a
movsd 0x18(%rsp), %xmm1
addsd %xmm1, %xmm1
movapd 0x20(%rsp), %xmm3
mulsd 0xd0e(%rip), %xmm3      # 0x2030
subsd %xmm1, %xmm3
subsd 0x10(%rsp), %xmm3
subsd %xmm0, %xmm3
mulsd 0xd00(%rip), %xmm3      # 0x2038
movsd 0xcc8(%rip), %xmm0      # 0x2008
addsd %xmm3, %xmm0
xorpd %xmm1, %xmm1
movapd %xmm3, %xmm2
cmpltsd %xmm1, %xmm2
andpd %xmm2, %xmm0
andnpd %xmm3, %xmm2
orpd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
andl $0xf, %eax
addq $0x30, %rsp
popq %rbx
retq
addq $-0x21238c8, %rax       # imm = 0xFDEDC738
movq %rax, 0x2cd9(%rip)      # 0x4050
movq 0x2c7a(%rip), %rbx      # 0x3ff8
movq (%rbx), %rdi
movl 0x2cd1(%rip), %edx      # 0x4058
incl %edx
movl %edx, 0x2cc9(%rip)      # 0x4058
leaq 0xcaa(%rip), %rsi       # 0x2040
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x1050
movq (%rbx), %rdi
callq 0x1060
movsd 0x8(%rsp), %xmm0
jmp 0x130a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movl %esi, %ebp
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %ebp
movq %rdi, %r14
leaq 0xc75(%rip), %r13       # 0x204d
xorl %ebx, %ebx
cmpl %ebp, %ebx
je 0x144d
testb $0x3, %bl
je 0x13f3
leaq 0xc60(%rip), %rdi       # 0x204a
xorl %eax, %eax
callq 0x1040
jmp 0x1418
testl %ebx, %ebx
je 0x1403
leaq 0xc60(%rip), %rdi       # 0x205e
callq 0x1030
leaq 0xc3c(%rip), %rdi       # 0x2046
movl 0x4(%rsp), %esi
pushq $0x20
popq %rdx
xorl %eax, %eax
callq 0x1040
xorl %r12d, %r12d
pushq $0x8
popq %r15
subl $0x1, %r15d
jb 0x143c
shll $0x4, %r12d
movl (%r14), %edi
leal 0x1(%rdi), %eax
movl %eax, (%r14)
callq 0x12ac
orl %eax, %r12d
jmp 0x141f
movq %r13, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x1040
incl %ebx
jmp 0x13da
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rbx
andl $0x0, (%rbx)
leaq 0xbea(%rip), %rdi       # 0x2060
callq 0x1030
pushq $0x12
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x13b6
leaq 0xc3f(%rip), %rdi       # 0x20cf
callq 0x1030
pushq $0x4
popq %r14
leaq 0xbbd(%rip), %r12       # 0x205d
leaq 0xbb7(%rip), %r13       # 0x205e
leaq 0xba8(%rip), %r15       # 0x2056
movl %r14d, %ebp
movl %r14d, %ebx
subl $0x1, %ebx
jb 0x14ef
leaq 0xc3b(%rip), %rdi       # 0x20fb
callq 0x1030
leaq 0x4(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movl %r14d, %edx
callq 0x13b6
cmpl $0x1, %ebp
movq %r13, %rsi
cmoveq %r12, %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1040
movl %ebx, %ebp
jmp 0x14b4
leaq 0xc02(%rip), %rdi       # 0x20f8
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
pushq $0x1
popq %rbx
movq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %r14
pushq $0x64
popq %rbp
leaq 0x2e8b(%rip), %r12      # 0x4070
pushq $0x1a
popq %r13
movq %r14, %rdi
movl %ebp, %esi
callq 0x125e
cmpl $-0x1, %eax
je 0x1243
movsbq 0x10(%rsp), %r15
cmpq $0xa, %r15
je 0x123e
callq 0x10b0
movq (%rax), %rax
testb $0x4, 0x1(%rax,%r15,2)
je 0x11e9
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x131a
cmpl $-0x1, %eax
jne 0x11e9
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1376
movq %rax, 0x8(%rsp)
jmp 0x11e9
incq %rbx
jmp 0x11e9
movq 0x8(%rsp), %rdi
callq 0x1408
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
testq %rdi, %rdi
je 0x13af
movq %rdi, %rbx
movq (%rdi), %rsi
movq %r15, %rdi
callq 0x1070
testl %eax, %eax
je 0x13da
jns 0x13ec
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1376
movq %rax, 0x10(%rbx)
jmp 0x13ff
pushq $0x20
popq %rdi
callq 0x1080
movq %rax, %rbx
movq %r14, %rsi
callq 0x14ac
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x144f
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
jmp 0x13ff
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x14ac
movq %rax, 0x8(%rbx)
jmp 0x13ff
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1376
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xc4f(%rip), %r14       # 0x2065
pushq $0xa
popq %rbp
testq %rbx, %rbx
je 0x144a
movq 0x10(%rbx), %rdi
callq 0x1408
movq (%rbx), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1060
movq 0x8(%rbx), %rdi
callq 0x14eb
movl %ebp, %edi
callq 0x1030
movq 0x18(%rbx), %rbx
jmp 0x1419
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0x14cd
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq %r14, %rsi
callq 0x14ac
movq %rax, 0x8(%rbx)
jmp 0x14e0
pushq $0x10
popq %rdi
callq 0x1080
movq %rax, %rbx
movq %r14, (%rax)
andq $0x0, 0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xb70(%rip), %r14       # 0x206a
leaq 0xb6b(%rip), %r15       # 0x206c
testq %rbx, %rbx
je 0x152c
cmpb $0x0, 0x2c37(%rip)      # 0x4144
movq %r14, %rdi
jne 0x151c
movb $0x1, 0x2c2b(%rip)      # 0x4144
movq %r15, %rdi
movq (%rbx), %rsi
xorl %eax, %eax
callq 0x1060
movq 0x8(%rbx), %rbx
jmp 0x1501
movb $0x0, 0x2c11(%rip)      # 0x4144
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mflatt[P]gc-demo/gengc/gengc.c
// Function: collect_garbage
void collect_garbage()
{
  if (!chunks) return;
  
  /* minor collection: */
  mark_and_sweep_from_roots();

  /* The minor collection above relies on having no references from
     old object to new objects; this is not a general-purpose GC. If
     such references were allowed, we'd have to add them as roots. */
  
  /* move non-empty chunks to old generation: */
  if (chunks) {
    struct gc_chunk *prev_c = NULL, *next;

    for (struct gc_chunk *c = chunks; c; c = next) {
      next = c->next;
      if (c->num_marked_nodes == 0) {
        /* This chunk is empty, so free it */
        raw_free(c->mem, NODES_PER_CHUNK * sizeof(struct gc_node));
        raw_free(c, sizeof(struct gc_chunk));
        if (!prev_c)
          chunks = next;
      } else {
        /* Keep this chunk, now as an old-generation chunk */
        num_gen1_chunks++;
        if (prev_c)
          prev_c->next = c;
        prev_c = c;
      }
    }

    if (prev_c) {
      prev_c->next = gen1_chunks;
      gen1_chunks = chunks;
    }

    chunks = NULL;
    free_list = NULL;
  }

  if (num_gen1_chunks >= (last_major_gen1_chunks * 2)) {
    /* perform major collection by moving all old-generation
       chunks back to the "new" generation, and GC again */
    // printf("Major GC\n");
    last_major_gen1_chunks = num_gen1_chunks;
    chunks = gen1_chunks;
    gen1_chunks = NULL;
    num_gen1_chunks = 0;
    collect_garbage();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2d2a(%rip), %r15      # 0x4080
movq (%r15), %rax
leaq 0x2d10(%rip), %r12      # 0x4070
pushq $0x18
popq %rbx
testq %rax, %rax
je 0x1425
xorl %eax, %eax
callq 0x14d9
movq (%r15), %r13
testq %r13, %r13
je 0x13ef
xorl %r14d, %r14d
movq %r14, %rbp
movq %r13, %r14
testq %r14, %r14
je 0x13cc
movq (%r14), %r13
cmpl $0x0, 0x10(%r14)
jne 0x13b6
movq 0x8(%r14), %rdi
movl $0xc0000, %esi          # imm = 0xC0000
callq 0x1336
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1336
movq %r13, %r14
testq %rbp, %rbp
jne 0x1384
jmp 0x13c7
incl 0x2c9c(%rip)            # 0x4058
testq %rbp, %rbp
je 0x137e
movq %r14, (%rbp)
jmp 0x137e
movq %r13, (%r15)
jmp 0x137b
testq %rbp, %rbp
je 0x13e6
movq 0x2c88(%rip), %rax      # 0x4060
movq %rax, (%rbp)
movq (%r15), %rax
movq %rax, 0x2c7a(%rip)      # 0x4060
andq $0x0, (%r15)
andq $0x0, (%r12)
movl 0x2c63(%rip), %eax      # 0x4058
movl 0x2c6d(%rip), %ecx      # 0x4068
addl %ecx, %ecx
cmpl %ecx, %eax
jl 0x1425
movl %eax, 0x2c61(%rip)      # 0x4068
movq 0x2c52(%rip), %rax      # 0x4060
andq $0x0, 0x2c4a(%rip)      # 0x4060
movq %rax, (%r15)
andl $0x0, 0x2c38(%rip)      # 0x4058
jmp 0x1363
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %eax
imulq $0x58, %rax, %r8
xorl %r9d, %r9d
xorl %eax, %eax
cmpq %r9, %r8
je 0x8583
movq 0x8(%rdi), %r10
movq 0x10(%r10,%r9), %r11
addq 0x8(%r10,%r9), %r11
cmpq %r11, %rax
cmovbeq %r11, %rax
addq $0x58, %r9
jmp 0x8563
movq %rax, (%rcx)
movq %rax, %rdi
jmp 0x283e
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0xa
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x21e0
leaq 0x4b6a(%rip), %rdi      # 0xdeef
pushq $0x26
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23f0
leaq 0x4b78(%rip), %rsi      # 0xdf16
leaq 0x4b14(%rip), %rdx      # 0xdeb9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2230
leaq 0x4b6e(%rip), %rdi      # 0xdf24
pushq $0x43
popq %r15
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23f0
leaq 0x4b99(%rip), %rdi      # 0xdf68
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23f0
movl %ebp, %edi
movq %rbx, %rsi
callq 0x21e0
movq 0x9be2(%rip), %rcx      # 0x12fd0
xorl %eax, %eax
cmpq %rbx, (%rcx)
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2892(%rip), %rdi      # 0xe492
pushq $0x65
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23f0
leaq 0x28df(%rip), %rdi      # 0xe4f8
pushq $0x9
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23f0
leaq 0x28d4(%rip), %rdi      # 0xe502
pushq $0x33
popq %r15
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23f0
leaq 0x28ef(%rip), %rdi      # 0xe536
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23f0
leaq 0x290e(%rip), %rdi      # 0xe56a
pushq $0x4b
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23f0
leaq 0x2945(%rip), %rdi      # 0xe5b6
pushq $0x5d
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23f0
leaq 0x298e(%rip), %rdi      # 0xe614
pushq $0x2a
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x23f0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq %rax, %rdi
shrq $0x20, %rdi
testw $0xf04, %di             # imm = 0xF04
setne %r8b
testw %di, %di
sete %dil
orb %r8b, %dil
jne 0xbe96
shrl $0x10, %eax
movzbl %al, %eax
movzbl %dl, %edx
cmpl %edx, %eax
jae 0xbea0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rsi), %rax
movslq (%r14), %rdx
movq (%rax,%rdx,8), %rax
movq %rax, (%r9)
movl 0x4(%r14), %eax
movl %eax, (%rcx)
movq %r14, %rdi
callq 0x3262
movl %eax, (%rbx)
movq 0x30(%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2420
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x26b3(%rip), %rdi      # 0xea99
pushq $0x51
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23f0
leaq 0x20f9(%rip), %rdi      # 0xe4f8
pushq $0x9
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23f0
leaq 0x26d7(%rip), %rdi      # 0xeaeb
pushq $0x58
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x23f0
leaq 0x6e37(%rip), %rax      # 0x13260
movl (%rax), %edi
callq 0xbccf
leaq 0x270d(%rip), %rsi      # 0xeb44
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2230
leaq 0x6e19(%rip), %rax      # 0x13264
movl (%rax), %edi
callq 0xbccf
leaq 0x272a(%rip), %rsi      # 0xeb83
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2230
leaq 0x6dff(%rip), %rax      # 0x1326c
movl (%rax), %edi
callq 0xc526
leaq 0x2742(%rip), %rsi      # 0xebbd
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2230
leaq 0x6de1(%rip), %rax      # 0x13270
movl (%rax), %edx
leaq 0x2761(%rip), %rsi      # 0xebf9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2230
leaq 0x216b(%rip), %rdi      # 0xe614
pushq $0x2a
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23f0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
cmpl $0x0, 0x1c(%rsp)
je 0x69ea
leaq 0x10(%rsp), %rbx
cmpb $0x0, 0x948cf(%rip)     # 0x9b285
jne 0x69bd
callq 0x69ec
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm2, 0x948d9(%rip)    # 0x9b2a8
movups %xmm1, 0x948c2(%rip)    # 0x9b298
movups %xmm0, 0x948ab(%rip)    # 0x9b288
movl (%rbx), %edx
pushq $0x10
popq %rsi
xorl %edi, %edi
popq %rbx
jmp 0x6e0e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/arkanis[P]process-map/./deps/raygui.h
// Function: GuiSetStyle
void GuiSetStyle(int control, int property, int value)
{
    if (!guiStyleLoaded) GuiLoadStyleDefault();
    guiStyle[control*(NUM_PROPS_DEFAULT + NUM_PROPS_EXTENDED) + property] = value;

    // Default properties are propagated to all controls
    if ((control == 0) && (property < NUM_PROPS_DEFAULT))
    {
        for (int i = 1; i < NUM_CONTROLS; i++) guiStyle[i*(NUM_PROPS_DEFAULT + NUM_PROPS_EXTENDED) + property] = value;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
cmpb $0x0, 0x94465(%rip)     # 0x9b285
jne 0x6e27
callq 0x69ec
imull $0x18, %r14d, %eax
addl %ebp, %eax
movslq %eax, %rcx
leaq 0x94489(%rip), %rax     # 0x9b2c0
movl %ebx, (%rax,%rcx,4)
testl %r14d, %r14d
setne %cl
cmpl $0x10, %ebp
setge %dl
orb %cl, %dl
jne 0x6e6a
movslq %ebp, %rcx
shlq $0x2, %rcx
pushq $0x60
popq %rdx
cmpq $0x600, %rdx            # imm = 0x600
je 0x6e6a
leaq (%rcx,%rdx), %rsi
movl %ebx, (%rax,%rsi)
addq $0x60, %rdx
jmp 0x6e54
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/arkanis[P]process-map/./deps/raygui.h
// Function: GuiStatusBar
void GuiStatusBar(Rectangle bounds, const char *text)
{
    GuiControlState state = guiState;

    // Draw control
    //--------------------------------------------------------------------
    GuiDrawRectangle(bounds, GuiGetStyle(STATUSBAR, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(STATUSBAR, (state != GUI_STATE_DISABLED)? BORDER_COLOR_NORMAL : BORDER_COLOR_DISABLED)), guiAlpha),
                     Fade(GetColor(GuiGetStyle(STATUSBAR, (state != GUI_STATE_DISABLED)? BASE_COLOR_NORMAL : BASE_COLOR_DISABLED)), guiAlpha));
    GuiDrawText(text, GetTextBounds(STATUSBAR, bounds), GuiGetStyle(STATUSBAR, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(STATUSBAR, (state != GUI_STATE_DISABLED)? TEXT_COLOR_NORMAL : TEXT_COLOR_DISABLED)), guiAlpha));
    //--------------------------------------------------------------------
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl 0x941ff(%rip), %r15d    # 0x9b280
pushq $0xf
popq %rbp
pushq $0xc
popq %rsi
movl %ebp, %edi
callq 0x6e93
movl %eax, %r14d
xorl %r12d, %r12d
cmpl $0x3, %r15d
sete %r12b
leal (%r12,%r12,8), %esi
movl %ebp, %edi
callq 0x6e93
movl %eax, %edi
callq 0x38400
movss 0x9338a(%rip), %xmm0    # 0x9a440
movl %eax, %edi
callq 0x380d5
movl %eax, %r15d
leal (%r12,%r12,8), %esi
incl %esi
movl %ebp, %edi
callq 0x6e93
movl %eax, %edi
callq 0x38400
movss 0x93364(%rip), %xmm0    # 0x9a440
movl %eax, %edi
callq 0x380d5
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movl %r14d, %edi
movl %r15d, %esi
movl %eax, %edx
callq 0x7476
movl %ebp, %edi
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
callq 0x8f04
movaps %xmm0, 0x10(%rsp)
movaps %xmm1, (%rsp)
pushq $0xe
popq %rsi
movl %ebp, %edi
callq 0x6e93
movl %eax, %r14d
leal (%r12,%r12,8), %esi
addl $0x2, %esi
movl %ebp, %edi
callq 0x6e93
movl %eax, %edi
callq 0x38400
movss 0x93304(%rip), %xmm0    # 0x9a440
movl %eax, %edi
callq 0x380d5
movq %rbx, %rdi
movaps 0x10(%rsp), %xmm0
movaps (%rsp), %xmm1
movl %r14d, %esi
movl %eax, %edx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8d31
// File: /workspace/github_c_makefile_star2_O2/arkanis[P]process-map/./deps/raygui.h
// Function: GuiButton
bool GuiButton(Rectangle bounds, const char *text)
{
    GuiControlState state = guiState;
    bool pressed = false;

    // Update control
    //--------------------------------------------------------------------
    if ((state != GUI_STATE_DISABLED) && !guiLocked)
    {
        Vector2 mousePoint = GetMousePosition();

        // Check button state
        if (CheckCollisionPointRec(mousePoint, bounds))
        {
            if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) state = GUI_STATE_PRESSED;
            else state = GUI_STATE_FOCUSED;

            if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) pressed = true;
        }
    }
    //--------------------------------------------------------------------

    // Draw control
    //--------------------------------------------------------------------
    GuiDrawRectangle(bounds, GuiGetStyle(BUTTON, BORDER_WIDTH), Fade(GetColor(GuiGetStyle(BUTTON, BORDER + (state*3))), guiAlpha), Fade(GetColor(GuiGetStyle(BUTTON, BASE + (state*3))), guiAlpha));
    GuiDrawText(text, GetTextBounds(BUTTON, bounds), GuiGetStyle(BUTTON, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(BUTTON, TEXT + (state*3))), guiAlpha));
    //------------------------------------------------------------------

    return pressed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl 0x94076(%rip), %r13d    # 0x9b280
cmpl $0x3, %r13d
jne 0x7216
pushq $0x3
popq %r13
jmp 0x724f
cmpb $0x0, 0x94067(%rip)     # 0x9b284
jne 0x724f
callq 0x1fd8b
movaps (%rsp), %xmm1
movaps 0x10(%rsp), %xmm2
callq 0x2a643
testb %al, %al
je 0x724f
xorl %edi, %edi
callq 0x1fdb3
movzbl %al, %r13d
incl %r13d
xorl %edi, %edi
callq 0x245dd
movl %eax, %ebp
jmp 0x7251
xorl %ebp, %ebp
pushq $0x2
popq %r14
pushq $0xc
popq %rsi
movl %r14d, %edi
callq 0x6e93
movl %eax, %r15d
leal (%r13,%r13,2), %esi
movl %r14d, %edi
callq 0x6e93
movl %eax, %edi
callq 0x38400
movss 0x931c1(%rip), %xmm0    # 0x9a440
movl %eax, %edi
callq 0x380d5
movl %eax, %r12d
leal 0x1(%r13,%r13,2), %esi
movl %r14d, %edi
callq 0x6e93
movl %eax, %edi
callq 0x38400
movss 0x9319b(%rip), %xmm0    # 0x9a440
movl %eax, %edi
callq 0x380d5
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movl %r15d, %edi
movl %r12d, %esi
movl %eax, %edx
callq 0x7476
movl %r14d, %edi
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
callq 0x8f04
movaps %xmm0, 0x10(%rsp)
movaps %xmm1, (%rsp)
pushq $0xe
popq %rsi
movl %r14d, %edi
callq 0x6e93
movl %eax, %r15d
leal 0x2(%r13,%r13,2), %esi
movl %r14d, %edi
callq 0x6e93
movl %eax, %edi
callq 0x38400
movss 0x9313a(%rip), %xmm0    # 0x9a440
movl %eax, %edi
callq 0x380d5
movq %rbx, %rdi
movaps 0x10(%rsp), %xmm0
movaps (%rsp), %xmm1
movl %r15d, %esi
movl %eax, %edx
callq 0x8d31
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/arkanis[P]process-map/./deps/raygui.h
// Function: GuiDrawRectangle
static void GuiDrawRectangle(Rectangle rec, int borderWidth, Color borderColor, Color color)
{
    if (color.a > 0)
    {
        // Draw rectangle filled with color
        DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, color);
    }

    if (borderWidth > 0)
    {
        // Draw rectangle border lines with color
        DrawRectangle((int)rec.x, (int)rec.y, (int)rec.width, borderWidth, borderColor);
        DrawRectangle((int)rec.x, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, borderColor);
        DrawRectangle((int)rec.x + (int)rec.width - borderWidth, (int)rec.y + borderWidth, borderWidth, (int)rec.height - 2*borderWidth, borderColor);
        DrawRectangle((int)rec.x, (int)rec.y + (int)rec.height - borderWidth, (int)rec.width, borderWidth, borderColor);
    }

    // TODO: For n-patch-based style we would need: [state] and maybe [control]
    // In this case all controls drawing logic should be moved to this function... I don't like it...
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %r15d
movl %edi, %r14d
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movaps %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm2     # xmm2 = xmm2[1,1],xmm1[1,1]
movaps %xmm2, (%rsp)
cmpl $0x1000000, %edx        # imm = 0x1000000
jb 0x74db
movl %edx, %r8d
cvttss2si %xmm0, %edi
cvttss2si %xmm3, %esi
cvttss2si %xmm1, %edx
cvttss2si (%rsp), %ecx
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm3, 0x20(%rsp)
callq 0x26d3a
movaps 0x20(%rsp), %xmm3
movaps 0x30(%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
testl %r14d, %r14d
jle 0x756d
cvttss2si %xmm0, %ebp
cvttss2si %xmm3, %r12d
cvttss2si %xmm1, %r13d
movl %ebp, %edi
movl %r12d, %esi
movl %r13d, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x26d3a
cvttss2si (%rsp), %ecx
movl %ecx, (%rsp)
leal (%r12,%r14), %esi
movl %esi, 0x10(%rsp)
movl %ecx, %ebx
subl %r14d, %ebx
subl %r14d, %ebx
movl %ebp, %edi
movl %r14d, %edx
movl %ebx, %ecx
movl %r15d, %r8d
callq 0x26d3a
movl %ebp, %edi
subl %r14d, %edi
addl %r13d, %edi
movl 0x10(%rsp), %esi
movl %r14d, %edx
movl %ebx, %ecx
movl %r15d, %r8d
callq 0x26d3a
subl %r14d, %r12d
addl (%rsp), %r12d
movl %ebp, %edi
movl %r12d, %esi
movl %r13d, %edx
movl %r14d, %ecx
movl %r15d, %r8d
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x26d3a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/arkanis[P]process-map/./deps/raygui.h
// Function: GuiLabel
void GuiLabel(Rectangle bounds, const char *text)
{
    GuiControlState state = guiState;

    // Update control
    //--------------------------------------------------------------------
    // ...
    //--------------------------------------------------------------------

    // Draw control
    //--------------------------------------------------------------------
    GuiDrawText(text, GetTextBounds(LABEL, bounds), GuiGetStyle(LABEL, TEXT_ALIGNMENT), Fade(GetColor(GuiGetStyle(LABEL, (state == GUI_STATE_DISABLED)? TEXT_COLOR_DISABLED : TEXT_COLOR_NORMAL)), guiAlpha));
    //--------------------------------------------------------------------
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x93b04(%rip), %r15d    # 0x9b280
pushq $0x1
popq %rbp
movl %ebp, %edi
callq 0x8f04
movaps %xmm0, 0x10(%rsp)
movaps %xmm1, (%rsp)
pushq $0xe
popq %rsi
movl %ebp, %edi
callq 0x6e93
movl %eax, %r14d
xorl %eax, %eax
cmpl $0x3, %r15d
sete %al
leal (%rax,%rax,8), %esi
addl $0x2, %esi
movl %ebp, %edi
callq 0x6e93
movl %eax, %edi
callq 0x38400
movss 0x92c7f(%rip), %xmm0    # 0x9a440
movl %eax, %edi
callq 0x380d5
movq %rbx, %rdi
movaps 0x10(%rsp), %xmm0
movaps (%rsp), %xmm1
movl %r14d, %esi
movl %eax, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8d31
// File: /workspace/github_c_makefile_star2_O2/arkanis[P]process-map/./deps/raygui.h
// Function: GetTextBounds
static Rectangle GetTextBounds(int control, Rectangle bounds)
{
    Rectangle textBounds = bounds;

    textBounds.x = bounds.x + GuiGetStyle(control, BORDER_WIDTH);
    textBounds.y = bounds.y + GuiGetStyle(control, BORDER_WIDTH);
    textBounds.width = bounds.width - 2*GuiGetStyle(control, BORDER_WIDTH);
    textBounds.height = bounds.height - 2*GuiGetStyle(control, BORDER_WIDTH);

    // Consider TEXT_PADDING properly, depends on control type and TEXT_ALIGNMENT
    switch (control)
    {
        case COMBOBOX: bounds.width -= (GuiGetStyle(control, COMBO_BUTTON_WIDTH) + GuiGetStyle(control, COMBO_BUTTON_PADDING)); break;
        case VALUEBOX: break;   // NOTE: ValueBox text value always centered, text padding applies to label
        default:
        {
            if (GuiGetStyle(control, TEXT_ALIGNMENT) == GUI_TEXT_ALIGN_RIGHT) textBounds.x -= GuiGetStyle(control, TEXT_PADDING);
            else textBounds.x += GuiGetStyle(control, TEXT_PADDING);
        } break;
    }

    // TODO: Special cases (no label): COMBOBOX, DROPDOWNBOX, LISTVIEW (scrollbar?)
    // More special cases (label side): CHECKBOX, SLIDER, VALUEBOX, SPINNER

    return textBounds;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl %edi, %r14d
pushq $0xc
popq %rbp
movl %ebp, %esi
callq 0x6e93
movl %eax, %ebx
movl %r14d, %edi
movl %ebp, %esi
callq 0x6e93
movd %ebx, %xmm0
movd %eax, %xmm1
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
cvtdq2ps %xmm0, %xmm0
addps (%rsp), %xmm0
movaps %xmm0, (%rsp)
movl %r14d, %edi
movl %ebp, %esi
callq 0x6e93
movl %eax, %ebx
movl %r14d, %edi
movl %ebp, %esi
callq 0x6e93
movl %eax, %ebp
cmpl $0xa, %r14d
je 0x8f85
cmpl $0x7, %r14d
jne 0x8f90
pushq $0x7
popq %r14
pushq $0x10
popq %rsi
movl %r14d, %edi
callq 0x6e93
pushq $0x11
popq %rsi
movl %r14d, %edi
callq 0x6e93
movaps 0x10(%rsp), %xmm1
movaps (%rsp), %xmm0
jmp 0x8fca
pushq $0xe
popq %rsi
movl %r14d, %edi
callq 0x6e93
movl %eax, %r15d
pushq $0xd
popq %rsi
movl %r14d, %edi
callq 0x6e93
cvtsi2ss %eax, %xmm1
cmpl $0x2, %r15d
jne 0x8fbd
movaps (%rsp), %xmm0
subss %xmm1, %xmm0
jmp 0x8fc5
movaps (%rsp), %xmm0
addss %xmm1, %xmm0
movaps 0x10(%rsp), %xmm1
movd %ebp, %xmm3
movd %ebx, %xmm2
punpckldq %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movq %xmm2, %xmm2            # xmm2 = xmm2[0],zero
paddd %xmm2, %xmm2
cvtdq2ps %xmm2, %xmm2
subps %xmm2, %xmm1
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq