LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: debug_wait_gdb
void
debug_wait_gdb(void)
{
  debug_backtrace();
  bool wait = true;
  volatile bool * const v = &wait;
  *v = true;

  time_t now;
  time(&now);
  struct tm nowtm;
  localtime_r(&now, &nowtm);
  char timestamp[64] = {};
  strftime(timestamp, 64, "%F %T %Z (%z)", &nowtm);

  char hostname[256] = {};
  gethostname(hostname, 256);
  char threadname[256];
  pthread_getname_np(pthread_self(), threadname, 256);

  const char * const pattern = "[Waiting GDB] %s %s @ %s\n    Attach me:   sudo -Hi gdb -p %d\n";
  fprintf(stderr, pattern, timestamp, threadname, hostname, getpid());
  fflush(stderr);
  // to continue: gdb> set var *v = 0
  while (*v) {
    sleep(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
callq 0x6d09
movb $0x1, -0x29(%rbp)
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x6360
leaq -0x70(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x60a0
vxorps %xmm0, %xmm0, %xmm0
leaq -0xb0(%rbp), %rbx
vmovups %ymm0, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0xb2b3(%rip), %rdx      # 0x12149
pushq $0x40
popq %rsi
movq %rbx, %rdi
movq %r14, %rcx
vzeroupper
callq 0x6440
leaq -0x2b0(%rbp), %r14
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0xe0(%r14)
vmovups %ymm0, 0xc0(%r14)
vmovups %ymm0, 0xa0(%r14)
vmovups %ymm0, 0x80(%r14)
vmovups %ymm0, 0x60(%r14)
vmovups %ymm0, 0x40(%r14)
vmovups %ymm0, 0x20(%r14)
vmovups %ymm0, (%r14)
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
vzeroupper
callq 0x6500
callq 0x6460
leaq -0x1b0(%rbp), %r15
movl $0x100, %edx            # imm = 0x100
movq %rax, %rdi
movq %r15, %rsi
callq 0x6040
movq 0x120d8(%rip), %r13     # 0x18ff8
movq (%r13), %r12
callq 0x6120
leaq 0xb227(%rip), %rsi      # 0x12157
movq %r12, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movq %r14, %r8
movl %eax, %r9d
xorl %eax, %eax
callq 0x6300
movq (%r13), %rdi
callq 0x63b0
pushq $0x1
popq %rbx
movb -0x29(%rbp), %al
cmpb $0x1, %al
jne 0x6f62
movl %ebx, %edi
callq 0x65c0
jmp 0x6f52
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: debug_catch_fatals
__attribute__((constructor))
  static void
debug_catch_fatals(void)
{
  struct sigaction sa = {};
  sa.sa_sigaction = __signal_handler_wait_gdb;
  sigemptyset(&(sa.sa_mask));
  sa.sa_flags = SA_SIGINFO;
  const int fatals[] = {SIGSEGV, SIGFPE, SIGILL, SIGBUS, 0};
  for (int i = 0; fatals[i]; i++) {
    if (sigaction(fatals[i], &sa, NULL) == -1) {
      fprintf(stderr, "Failed to set signal handler for %s\n", strsignal(fatals[i]));
      fflush(stderr);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq -0xb8(%rbp), %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x70(%rbx)
vmovups %ymm0, 0x60(%rbx)
vmovups %ymm0, 0x40(%rbx)
vmovups %ymm0, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0x95(%rip), %rax        # 0x7057
movq %rax, -0x8(%rbx)
movq %rbx, %rdi
vzeroupper
callq 0x6310
movl $0x4, 0x80(%rbx)
leaq 0xb83e(%rip), %r13      # 0x12820
leaq -0xc0(%rbp), %rbx
xorl %r14d, %r14d
cmpq $0x10, %r14
je 0x7045
movl (%r14,%r13), %r15d
movl %r15d, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x60e0
cmpl $-0x1, %eax
je 0x700e
addq $0x4, %r14
jmp 0x6fec
movq 0x11fe3(%rip), %rax     # 0x18ff8
movq (%rax), %r12
movl %r15d, %edi
callq 0x63e0
movq %r12, %rdi
leaq 0xb16b(%rip), %rsi      # 0x12195
movq %rax, %rdx
xorl %eax, %eax
callq 0x6300
movq 0x11fbd(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
callq 0x63b0
jmp 0x7008
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: debug_dump_maps
void
debug_dump_maps(FILE * const out)
{
  FILE * const in = fopen("/proc/self/smaps", "r");
  char * line0 = malloc(1024);
  size_t size0 = 1024;
  while (!feof(in)) {
    const ssize_t r1 = getline(&line0, &size0, in);
    if (r1 < 0) break;
    fprintf(out, "%s", line0);
  }
  fflush(out);
  fclose(in);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xb12a(%rip), %rdi      # 0x121ba
leaq 0xb175(%rip), %rsi      # 0x1220c
callq 0x6480
movq %rax, %r14
movl $0x400, %edi            # imm = 0x400
callq 0x63a0
leaq -0x28(%rbp), %r15
movq %rax, (%r15)
leaq -0x30(%rbp), %r12
movq $0x400, (%r12)          # imm = 0x400
movq %r14, %rdi
callq 0x6330
testl %eax, %eax
jne 0x70e9
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x64f0
testq %rax, %rax
js 0x70e9
movq -0x28(%rbp), %rdi
movq %rbx, %rsi
callq 0x6200
jmp 0x70bc
movq %rbx, %rdi
callq 0x63b0
movq %r14, %rdi
callq 0x6140
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: debug_perf_start
void
debug_perf_start(void)
{
  const pid_t self = getpid();
  const pid_t perfpid = fork();
  if (perfpid < 0) {
    fprintf(stderr, "%s fork() failed\n", __func__);
  } else if (perfpid == 0) {
    // call perf
    char buf[10];
    sprintf(buf, "%d", self);
    char * args[10] = {};
    args[0] = "perf";
    args[1] = "record";
    args[2] = "--call-graph";
    args[3] = "lbr";
    args[4] = "--switch-output";
    args[5] = "-s";
    args[6] = "-p";
    args[7] = buf;
    args[8] = NULL;
    execvp(args[0], args);
    fprintf(stderr, "%s execvp() failed\n", __func__);
    fflush(stderr);
    exit(0);
  } else {
    __perf_pid = perfpid;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
callq 0x6120
movl %eax, %ebx
callq 0x65e0
testl %eax, %eax
js 0x7132
je 0x7159
movl %eax, 0x1221f(%rip)     # 0x19348
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x11ebf(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
leaq 0xb088(%rip), %rsi      # 0x121cb
leaq 0xb093(%rip), %rdx      # 0x121dd
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x6300
leaq 0xb08e(%rip), %rsi      # 0x121ee
leaq -0x1a(%rbp), %r14
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x6520
vxorps %xmm0, %xmm0, %xmm0
leaq -0x70(%rbp), %rsi
vmovaps %xmm0, 0x40(%rsi)
leaq 0xb06d(%rip), %rdi      # 0x121f1
movq %rdi, (%rsi)
leaq 0xb068(%rip), %rax      # 0x121f6
movq %rax, 0x8(%rsi)
leaq 0xb064(%rip), %rax      # 0x121fd
movq %rax, 0x10(%rsi)
leaq 0xb066(%rip), %rax      # 0x1220a
movq %rax, 0x18(%rsi)
leaq 0xb05f(%rip), %rax      # 0x1220e
movq %rax, 0x20(%rsi)
leaq 0xb064(%rip), %rax      # 0x1221e
movq %rax, 0x28(%rsi)
leaq 0xb05c(%rip), %rax      # 0x12221
movq %rax, 0x30(%rsi)
movq %r14, 0x38(%rsi)
callq 0x64d0
movq 0x11e1f(%rip), %rbx     # 0x18ff8
movq (%rbx), %rdi
leaq 0xb041(%rip), %rsi      # 0x12224
leaq 0xaff3(%rip), %rdx      # 0x121dd
xorl %eax, %eax
callq 0x6300
movq (%rbx), %rdi
callq 0x63b0
xorl %edi, %edi
callq 0x6530
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: bitmap_create
inline struct bitmap *
bitmap_create(const u64 bits)
{
  struct bitmap * const bm = (typeof(bm))calloc(1, sizeof(*bm) + (sizeof(u64) * ((bits + 63) >> 6)));
  bm->bits = bits;
  atomic_store(&(bm->ones), 0);
  return bm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3f(%rdi), %rax
shrq $0x6, %rax
leaq 0x10(,%rax,8), %rsi
pushq $0x1
popq %rdi
callq 0x62d0
movq %rbx, (%rax)
xorl %ecx, %ecx
xchgq %rcx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: bf_create
inline struct bloomfilter *
bf_create(const u64 bpk, const u64 capacity)
{
  struct bitmap * const bm = bitmap_create(bpk * capacity);
  if (bm) {
    struct bloomfilter * const bf = malloc(sizeof(*bf));
    bf->nr_probe = log(2.0) * (double)bpk;
    bf->bm = bm;
    return bf;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
imulq %rdi, %rsi
movq %rsi, %rdi
callq 0x7306
testq %rax, %rax
je 0x74c3
movq %rax, %r14
pushq $0x10
popq %rdi
callq 0x63a0
vcvtusi2sd %rbx, %xmm0, %xmm0
vmulsd 0xabac(%rip), %xmm0, %xmm0 # 0x12060
vcvttsd2usi %xmm0, %rcx
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
jmp 0x74c5
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: bf_mark
inline void
bf_mark(struct bloomfilter * const bf, u64 hash64)
{
  u64 t = hash64;
  const u64 inc = bits_rotl_u64(hash64, 31);
  struct bitmap * const bm = bf->bm;
  for (u64 i = 0; i < bf->nr_probe; i++) {
    bitmap_set1(bm, t % bm->bits);
    t += inc;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
rorxq $0x21, %rsi, %r12
movq 0x8(%rdi), %r15
xorl %r13d, %r13d
cmpq (%r14), %r13
jae 0x750b
movq %rbx, %rax
xorl %edx, %edx
divq (%r15)
movq %r15, %rdi
movq %rdx, %rsi
callq 0x7379
addq %r12, %rbx
incq %r13
jmp 0x74eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: bf_test
inline bool
bf_test(const struct bloomfilter * const bf, u64 hash64)
{
  u64 t = hash64;
  const u64 inc = bits_rotl_u64(hash64, 31);
  const struct bitmap * const bm = bf->bm;
  for (u64 i = 0; i < bf->nr_probe; i++) {
    if (bitmap_test(bm, t % bm->bits) == false) return false;
    t += inc;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
rorxq $0x21, %rsi, %r12
movq (%rdi), %r15
movq 0x8(%rdi), %r14
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x755f
movq %rbx, %rax
xorl %edx, %edx
divq (%r14)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x7337
testb %al, %al
je 0x755f
addq %r12, %rbx
incq %r13
jmp 0x753b
cmpq %r15, %r13
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: process_get_rss
u64
process_get_rss(void)
{
  u64 size;
  u64 rss;
  FILE * const fp = fopen("/proc/self/statm", "r");
  if (fp == NULL) return 0;
  if (fscanf(fp, "%" PRIu64 "%" PRIu64, &size, &rss) != 2) {
    fclose(fp);
    return 0;
  }
  fclose(fp);
  return rss * (u64)sysconf(_SC_PAGESIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0xac90(%rip), %rdi      # 0x12238
leaq 0xac5d(%rip), %rsi      # 0x1220c
callq 0x6480
testq %rax, %rax
je 0x75fd
movq %rax, %r14
leaq 0xac86(%rip), %rsi      # 0x12249
xorl %ebx, %ebx
leaq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rcx
movq %rax, %rdi
xorl %eax, %eax
callq 0x60b0
movl %eax, %r15d
movq %r14, %rdi
callq 0x6140
cmpl $0x2, %r15d
jne 0x75ff
movq -0x20(%rbp), %r14
pushq $0x1e
popq %rdi
callq 0x64a0
movq %rax, %rbx
imulq %r14, %rbx
jmp 0x75ff
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: process_affinity_core_count
u64
process_affinity_core_count(void)
{
  size_t xsize = 0;
  cpu_set_t * const set = __cpu_set_alloc(&xsize);
  if (sched_getaffinity(0, xsize, set) != 0) {
    return sysconf(_SC_NPROCESSORS_CONF);
  }
  const int nr = CPU_COUNT_S(xsize, set);
  free(set);
  return (nr > 0) ? nr : sysconf(_SC_NPROCESSORS_CONF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x18(%rbp), %r14
andq $0x0, (%r14)
movq %r14, %rdi
callq 0x7676
movq %rax, %rbx
movq (%r14), %r14
xorl %edi, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6580
testl %eax, %eax
je 0x764f
pushq $0x53
popq %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x64a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6150
movl %eax, %r14d
movq %rbx, %rdi
callq 0x6060
testl %r14d, %r14d
jle 0x763f
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: _cpu_set_alloc
static inline cpu_set_t *
__cpu_set_alloc(size_t * const size_out)
{
  const int ncpu = sysconf(_SC_NPROCESSORS_CONF);
  const size_t s1 = CPU_ALLOC_SIZE(ncpu);
  const size_t s2 = sizeof(cpu_set_t);
  const size_t size = s1 > s2 ? s1 : s2;
  *size_out = size;
  cpu_set_t * const set = malloc(size);
  return set;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x53
popq %rdi
callq 0x64a0
cltq
addq $0x3f, %rax
shrq $0x3, %rax
andq $-0x8, %rax
cmpq $0x81, %rax
movl $0x80, %edi
cmovaeq %rax, %rdi
movq %rdi, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x63a0
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: process_affinity_core_list
u64
process_affinity_core_list(const u64 max, u64 * const cores)
{
  memset(cores, 0, max * sizeof(cores[0]));
  size_t xsize = 0;
  cpu_set_t * const set = __cpu_set_alloc(&xsize);
  if (sched_getaffinity(0, xsize, set) != 0) return 0;

  const u64 ncpu = sysconf(_SC_NPROCESSORS_CONF);
  const u64 nr_affinity = CPU_COUNT_S(xsize, set);
  const u64 nr = nr_affinity < max ? nr_affinity : max;
  u64 j = 0;
  for (u64 i = 0; i < ncpu; i++) {
    if (CPU_ISSET_S((int)i, xsize, set)) {
      cores[j++] = i;
    }
    if (j >= nr) break;
  }
  free(set);
  return j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq (,%rdi,8), %rdx
xorl %r12d, %r12d
movq %rsi, -0x30(%rbp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x6210
leaq -0x38(%rbp), %rbx
andq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x7676
movq %rax, %r15
movq (%rbx), %r13
xorl %edi, %edi
movq %r13, %rsi
movq %rax, %rdx
callq 0x6580
testl %eax, %eax
jne 0x777a
pushq $0x53
popq %rdi
callq 0x64a0
movq %rax, %rbx
movq %r13, %rdi
movq %r15, %rsi
callq 0x6150
cltq
cmpq %r14, %rax
cmovbq %rax, %r14
xorl %eax, %eax
movabsq $0x100000000, %rcx      # imm = 0x100000000
xorl %r12d, %r12d
xorl %edx, %edx
movq -0x30(%rbp), %r8
cmpq %rdx, %rbx
je 0x7772
movq %rax, %rsi
sarq $0x20, %rsi
movq %rsi, %rdi
shrq $0x3, %rdi
cmpq %r13, %rdi
jae 0x7767
shrq $0x6, %rsi
movq (%r15,%rsi,8), %rsi
btq %rdx, %rsi
jae 0x7767
movq %rdx, (%r8,%r12,8)
incq %r12
incq %rdx
addq %rcx, %rax
cmpq %r14, %r12
jb 0x773a
movq %r15, %rdi
callq 0x6060
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: thread_set_affinity
void
thread_set_affinity(const u64 cpu)
{
  const u64 ncpu = sysconf(_SC_NPROCESSORS_CONF);
  size_t xsize = 0;
  cpu_set_t * const set = __cpu_set_alloc(&xsize);

  CPU_ZERO_S(xsize, set);
  CPU_SET_S(cpu % ncpu, xsize, set);
  sched_setaffinity(0, xsize, set);
  free(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
pushq $0x53
popq %rdi
callq 0x64a0
movq %rax, %r12
leaq -0x28(%rbp), %r14
andq $0x0, (%r14)
movq %r14, %rdi
callq 0x7676
movq %rax, %rbx
movq (%r14), %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x6210
movq %r15, %rax
xorl %edx, %edx
divq %r12
movq %rdx, %rax
shrq $0x3, %rax
cmpq %r14, %rax
jae 0x7830
pushq $0x1
popq %rax
shlxq %rdx, %rax, %rax
shrq $0x6, %rdx
orq %rax, (%rbx,%rdx,8)
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6250
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6060
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: thread_fork_join
inline double
thread_fork_join(const u64 nr, void *(*func) (void *), void * const arg)
{
  const u64 nthreads = nr ? nr : process_affinity_core_count();
  void * argv[nthreads];
  for (u64 i = 0; i < nthreads; i++) {
    argv[i] = arg;
  }
  return thread_fork_join_private(nthreads, func, argv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
testq %rdi, %rdi
jne 0x7a8d
callq 0x760d
movq %rax, %rdi
movq %rsp, %rdx
leaq 0xf(,%rdi,8), %rax
andq $-0x10, %rax
subq %rax, %rdx
movq %rdx, %rsp
xorl %eax, %eax
cmpq %rax, %rdi
je 0x7ab2
movq %r14, (%rdx,%rax,8)
incq %rax
jmp 0x7aa4
movq %rbx, %rsi
callq 0x7851
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: thread_create_at
inline int
thread_create_at(const u64 cpu, pthread_t * const thread, void *(*start_routine) (void *), void * const arg)
{
  const u64 ncpu = sysconf(_SC_NPROCESSORS_CONF);
  const u64 cpu_id = cpu % ncpu;
  pthread_attr_t attr;
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  size_t xsize = 0;
  cpu_set_t * const set = __cpu_set_alloc(&xsize);

  CPU_ZERO_S(xsize, set);
  CPU_SET_S(cpu_id, xsize, set);
  pthread_attr_setaffinity_np(&attr, xsize, set);
  const int r = pthread_create(thread, &attr, start_routine, arg);
  pthread_attr_destroy(&attr);
  free(set);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x53
popq %rdi
callq 0x64a0
movq %rax, %rcx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r13
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x62b0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6380
leaq -0x38(%rbp), %rbx
andq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x7676
movq %rax, %r12
movq (%rbx), %rbx
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x6210
movq %r13, %rax
shrq $0x3, %rax
cmpq %rbx, %rax
jae 0x7b4c
pushq $0x1
popq %rax
shlxq %r13, %rax, %rax
shrq $0x6, %r13
orq %rax, (%r12,%r13,8)
leaq -0x70(%rbp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x6080
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq -0x30(%rbp), %rcx
callq 0x6430
movl %eax, %ebx
movq %r13, %rdi
callq 0x64c0
movq %r12, %rdi
callq 0x6060
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: pages_alloc_best
void *
pages_alloc_best(const size_t size, const bool try_1gb, u64 * const size_out)
{
  if (try_1gb) {
    const size_t nr_1gb = (size + ((UINT64_C(1) << 30) - UINT64_C(1))) >> 30;
    // 1gb super huge page: waste < 1/16 or 6.25%
    if (((nr_1gb << 30) - size) < (size >> 4)) {
      void * const p1 = pages_alloc_1gb(nr_1gb);
      if (p1) {
        *size_out = nr_1gb << 30;
        return p1;
      }
    }
  }

  // 2mb huge page: at least 1MB
  if (size >= (UINT64_C(1) << 20)) {
    const size_t nr_2mb = (size + ((UINT64_C(1) << 21) - UINT64_C(1))) >> 21;
    void * const p2 = pages_alloc_2mb(nr_2mb);
    if (p2) {
      *size_out = nr_2mb << 21;
      return p2;
    }
  }

  const size_t nr_4kb = (size + ((UINT64_C(1) << 12) - UINT64_C(1))) >> 12;
  void * const p3 = pages_alloc_4kb(nr_4kb);
  if (p3) {
    *size_out = nr_4kb << 12;
  }
  return p3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testl %esi, %esi
je 0x7c6e
leaq 0x3fffffff(%r14), %rdi
movq %rdi, %r15
andq $-0x40000000, %r15      # imm = 0xC0000000
movq %r15, %rax
subq %r14, %rax
movq %r14, %rcx
shrq $0x4, %rcx
cmpq %rcx, %rax
jae 0x7c6e
shrq $0x1e, %rdi
callq 0x7bc6
testq %rax, %rax
jne 0x7cba
cmpq $0x100000, %r14         # imm = 0x100000
jb 0x7c98
leaq 0x1fffff(%r14), %r15
movq %r15, %rdi
shrq $0x15, %rdi
callq 0x7c09
testq %rax, %rax
je 0x7c98
andq $-0x200000, %r15        # imm = 0xFFE00000
jmp 0x7cba
addq $0xfff, %r14            # imm = 0xFFF
movq %r14, %rdi
shrq $0xc, %rdi
callq 0x7c19
testq %rax, %rax
je 0x7cbf
andq $-0x1000, %r14          # imm = 0xF000
movq %r14, %r15
movq %r15, (%rbx)
jmp 0x7cc1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: oalloc_create
struct oalloc *
oalloc_create(void)
{
  struct oalloc * const oa = (typeof(oa))calloc(1, sizeof(*oa));
  spinlock_init(&(oa->lp.lock));
  for (u64 i = 0; i < OALLOC_NR_SHARDS; i++) {
    spinlock_init(&(oa->sps[i].lock));
  }
  return oa;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
pushq $0x1
popq %rdi
movl $0x15f90, %esi          # imm = 0x15F90
callq 0x62d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x6aec
movl $0x1f90, %r14d          # imm = 0x1F90
cmpq $0x15f90, %r14          # imm = 0x15F90
je 0x7d09
leaq (%rbx,%r14), %rdi
callq 0x6aec
addq $0x50, %r14
jmp 0x7cf1
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: oalloc_alloc
void *
oalloc_alloc(const u64 size, struct oalloc * const oa)
{
  const u64 s = random_u64() % OALLOC_NR_SHARDS;
  struct oalloc_sp * const sp = &(oa->sps[s]);
  const u64 asize = (size + 7) & (~ UINT64_C(7));
  spinlock_lock(&(sp->lock));
  if (sp->unit == NULL || ((sp->offset + asize) > OALLOC_UNIT_SIZE)) {
    sp->unit = oalloc_lp_alloc(&(oa->lp));
    sp->offset = 0;
    if (sp->unit == NULL) {
      spinlock_unlock(&(sp->lock));
      return NULL;
    }
  }
  void * const ptr = &(sp->unit[sp->offset]);
  sp->offset += asize;
  spinlock_unlock(&(sp->lock));
  return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x7e33
andl $0x3ff, %eax            # imm = 0x3FF
imulq $0x50, %rax, %rax
leaq (%r15,%rax), %r14
addq $0x1f90, %r14           # imm = 0x1F90
addq $0x7, %rbx
andq $-0x8, %rbx
movq %r14, %rdi
callq 0x6afb
movq 0x40(%r14), %r12
testq %r12, %r12
je 0x7d6c
movq 0x48(%r14), %rax
leaq (%rax,%rbx), %rcx
cmpq $0x40001, %rcx          # imm = 0x40001
jb 0x7e0a
movq %r15, %rdi
callq 0x6afb
movq 0x40(%r15), %r13
movq 0x48(%r15), %r12
cmpq $0x1000, %r12           # imm = 0x1000
jb 0x7d94
incq %r13
movq %r13, 0x40(%r15)
andq $0x0, 0x48(%r15)
xorl %r12d, %r12d
cmpq $0x3e7, %r13            # imm = 0x3E7
jbe 0x7da2
xorl %r12d, %r12d
jmp 0x7df2
movq 0x50(%r15,%r13,8), %rax
movq %r12, %rcx
testq %rax, %rax
jne 0x7de4
leaq -0x30(%rbp), %rdx
andq $0x0, (%rdx)
pushq $0x1
popq %rsi
movl $0x40000000, %edi       # imm = 0x40000000
callq 0x7c29
movq %rax, 0x50(%r15,%r13,8)
leaq -0x30(%rbp), %rcx
cmpq $0x40000000, (%rcx)     # imm = 0x40000000
je 0x7de0
callq 0x6e43
movq 0x50(%r15,%r13,8), %rax
movq 0x48(%r15), %rcx
shlq $0x12, %r12
addq %rax, %r12
incq %rcx
movq %rcx, 0x48(%r15)
movq %r15, %rdi
callq 0x6320
movq %r12, 0x40(%r14)
andq $0x0, 0x48(%r14)
xorl %eax, %eax
testq %r12, %r12
je 0x7e16
addq %rax, %r12
addq %rax, %rbx
movq %rbx, 0x48(%r14)
jmp 0x7e19
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x6320
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: oalloc_destroy
void
oalloc_destroy(struct oalloc * const oa)
{
  for (u64 i = 0; i < OALLOC_NR_PAGE; i++) {
    if (oa->lp.pages[i]) {
      pages_unmap(oa->lp.pages[i], OALLOC_PAGE_SIZE);
    }
  }
  free(oa);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0xa
popq %r14
cmpq $0x3f2, %r14            # imm = 0x3F2
je 0x7e7f
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x7e7a
movl $0x40000000, %esi       # imm = 0x40000000
callq 0x6410
incq %r14
jmp 0x7e5e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6060
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: gcache_create
struct gcache *
gcache_create(const u64 nr_classes, const u64 inc)
{
  struct gcache * const g = (typeof(g))calloc(1, sizeof(*g) + (nr_classes * sizeof(g->cs[0])));
  for (u64 i = 0; i < GALLOC_SHARDS; i++) {
    spinlock_init(&(g->locks[i]));
  }
  g->nr = nr_classes;
  g->inc = inc;
  return g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %rsi
shlq $0x8, %rsi
addq $0x810, %rsi            # imm = 0x810
pushq $0x1
popq %rdi
callq 0x62d0
movq %rax, %r15
xorl %r12d, %r12d
cmpq $0x800, %r12            # imm = 0x800
je 0x7ed0
leaq (%r15,%r12), %rdi
callq 0x6aec
addq $0x40, %r12
jmp 0x7eb8
movq %r14, 0x800(%r15)
movq %rbx, 0x808(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: gcache_pull
void *
gcache_pull(struct gcache * const g, const u64 size)
{
  const u64 idx = (size + g->inc - 1) / g->inc;
  if (idx >= g->nr || idx == 0) return NULL;
  struct gcache_class * const gc = &(g->cs[idx]);
  return gcache_pull_gc(g, gc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x808(%rdi), %rcx
decq %rsi
leaq (%rsi,%rcx), %rax
xorl %edx, %edx
divq %rcx
xorl %r15d, %r15d
addq %rcx, %rsi
jb 0x7f9a
cmpq 0x800(%rdi), %rax
jae 0x7f9a
shlq $0x8, %rax
movq %rdi, -0x30(%rbp)
leaq (%rdi,%rax), %r13
addq $0x810, %r13            # imm = 0x810
callq 0x7e33
movq %rax, -0x38(%rbp)
xorl %ebx, %ebx
cmpq $0x20, %rbx
je 0x7f85
movq -0x38(%rbp), %rax
leal (%rax,%rbx), %r14d
andl $0x1f, %r14d
cmpq $0x0, (%r13,%r14,8)
je 0x7f80
movl %r14d, %r12d
shll $0x6, %r12d
addq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x6afb
movq (%r13,%r14,8), %r15
testq %r15, %r15
jne 0x7f8a
movq %r12, %rdi
callq 0x6320
incq %rbx
jmp 0x7f41
xorl %r15d, %r15d
jmp 0x7f9a
movq (%r15), %rax
movq %rax, (%r13,%r14,8)
movq %r12, %rdi
callq 0x6320
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: gcache_push
bool
gcache_push(struct gcache * const g, const u64 size, void * ptr)
{
  struct gcache_object * const go = (typeof(go))ptr;
  const u64 idx = (size + g->inc - 1) / g->inc;
  if (idx >= g->nr || idx == 0) return false;
  struct gcache_class * const gc = &(g->cs[idx]);
  gcache_push_gc(g, gc, go);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r8
movq %rdi, %r15
movq 0x808(%rdi), %rdi
leaq (%rsi,%rdi), %rcx
decq %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
movq %rax, %r12
cmpq 0x800(%r15), %rax
setb %al
cmpq %rcx, %rdi
setbe %r14b
andb %al, %r14b
cmpb $0x1, %r14b
jne 0x803a
shlq $0x8, %r12
addq %r15, %r12
movq %r8, -0x30(%rbp)
callq 0x7e33
movq %rax, %rbx
andl $0x1f, %ebx
movl %ebx, %r13d
shll $0x6, %r13d
addq %r15, %r13
movq %r13, %rdi
callq 0x6afb
movq 0x810(%r12,%rbx,8), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
movq %rcx, 0x810(%r12,%rbx,8)
movq %r13, %rdi
callq 0x6320
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: gcache_clean
void
gcache_clean(struct gcache * const g)
{
  for (u64 i = 0; i < GALLOC_SHARDS; i++) {
    spinlock_lock(&(g->locks[i]));
  }
  for (u64 i = 1; i < g->nr; i++) {
    memset(&(g->cs[i]), 0, sizeof(g->cs[i]));
  }
  for (u64 i = 0; i < GALLOC_SHARDS; i++) {
    spinlock_unlock(&(g->locks[i]));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x800, %r14            # imm = 0x800
je 0x8071
leaq (%rbx,%r14), %rdi
callq 0x6afb
addq $0x40, %r14
jmp 0x8059
leaq 0x910(%rbx), %rax
pushq $0x1
popq %rcx
vxorps %xmm0, %xmm0, %xmm0
cmpq 0x800(%rbx), %rcx
jae 0x80c6
vmovups %ymm0, 0xe0(%rax)
vmovups %ymm0, 0xc0(%rax)
vmovups %ymm0, 0xa0(%rax)
vmovups %ymm0, 0x80(%rax)
vmovups %ymm0, 0x60(%rax)
vmovups %ymm0, 0x40(%rax)
vmovups %ymm0, 0x20(%rax)
vmovups %ymm0, (%rax)
incq %rcx
addq $0x100, %rax            # imm = 0x100
jmp 0x807f
xorl %r14d, %r14d
cmpq $0x800, %r14            # imm = 0x800
je 0x80e4
leaq (%rbx,%r14), %rdi
vzeroupper
callq 0x6320
addq $0x40, %r14
jmp 0x80c9
popq %rbx
popq %r14
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: gcache_iter_create
struct gcache_iter *
gcache_iter_create(struct gcache * const g)
{
  struct gcache_iter * const gi = calloc(1, sizeof(*gi));
  gi->g = g;
  gi->cid = 1;
  gi->curr = g->cs[1].heads[0];
  return gi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x62d0
movq %rbx, (%rax)
movq $0x1, 0x8(%rax)
movq 0x910(%rbx), %rcx
movq %rcx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: gcache_iter_next
void *
gcache_iter_next(struct gcache_iter * const gi)
{
  if (gi->cid >= gi->g->nr) return NULL;
  while (gi->curr == NULL) {
    gi->sid++;
    if (gi->sid >= GALLOC_SHARDS) {
      gi->cid++;
      gi->sid = 0;
    }
    if (gi->cid >= gi->g->nr) return NULL;
    gi->curr = gi->g->cs[gi->cid].heads[gi->sid];
  }
  struct gcache_object * const curr = gi->curr;
  gi->curr = curr->next;
  return curr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
cmpq 0x800(%rcx), %rdx
jae 0x8187
movq 0x18(%rdi), %rax
leaq 0x810(%rcx), %rsi
testq %rax, %rax
jne 0x818b
movq 0x10(%rdi), %rax
incq %rax
movq %rax, 0x10(%rdi)
cmpq $0x20, %rax
jb 0x816a
incq %rdx
movq %rdx, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
cmpq 0x800(%rcx), %rdx
jae 0x8187
movq %rdx, %r8
shlq $0x8, %r8
addq %rsi, %r8
movq (%r8,%rax,8), %rax
movq %rax, 0x18(%rdi)
jmp 0x8146
xorl %eax, %eax
jmp 0x8192
movq (%rax), %rcx
movq %rcx, 0x18(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: cpu_clflush
inline void
cpu_clflush(void * const ptr, const size_t size)
{
  u8 * first = (typeof(first))(((u64)ptr) & (~ UINT64_C(0x3f)));
  u8 * const last  = (typeof(last))(((u64)(((u8*)ptr) + (size - 1u))) & (~ UINT64_C(0x3f)));
  while ((last - first) >= 256) {
    __builtin_ia32_clflush(first);
    __builtin_ia32_clflush(first + 64);
    __builtin_ia32_clflush(first + 128);
    __builtin_ia32_clflush(first + 192);
    first += 256;
  }
  for (u8 * p = first; p <= last; p += 64u) {
    __builtin_ia32_clflush(p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq (%rdi,%rsi), %rax
decq %rax
andq $-0x40, %rdi
andq $-0x40, %rax
movq %rax, %rcx
subq %rdi, %rcx
cmpq $0xff, %rcx
jle 0x81f5
clflush (%rdi)
clflush 0x40(%rdi)
clflush 0x80(%rdi)
clflush 0xc0(%rdi)
addq $0x100, %rdi            # imm = 0x100
addq $-0x100, %rcx
jmp 0x81c0
clflush (%rdi)
addq $0x40, %rdi
cmpq %rax, %rdi
jbe 0x81ee
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: qsort_u64_sample
void
qsort_u64_sample(const u64 * const array0, const u64 nr, const u64 res, FILE * const out)
{
  const u64 datasize = nr * sizeof(array0[0]);
  u64 * const array = (typeof(array))malloc(datasize);
  debug_assert(array);
  memcpy(array, array0, datasize);
  qsort_u64(array, nr);

  const double sized = (double)nr;
  const u64 srate = res ? res : 64;
  const u64 xstep = ({u64 step = nr / srate; step ? step : 1; });
  const u64 ystep = ({u64 step = (array[nr - 1] - array[0]) / srate; step ? step : 1; });
  u64 i = 0;
  fprintf(out, "%lu %06.2lf %lu\n", i, ((double)(i + 1lu)) * 100.0 / sized, array[i]);
  for (u64 j = 1; j < nr; j++) {
    if (((j - i) >= xstep) || (array[j] - array[i]) >= ystep) {
      i = j;
      fprintf(out, "%lu %06.2lf %lu\n", i, ((double)(i + 1lu)) * 100.0 / sized, array[i]);
    }
  }
  if (i != (nr - 1)) {
    i = nr - 1;
    fprintf(out, "%lu %06.2lf %lu\n", i, ((double)(i + 1lu)) * 100.0 / sized, array[i]);
  }
  free(array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
leaq (,%rsi,8), %r12
movq %r12, %rdi
callq 0x63a0
movq %rax, %rbx
testq %rax, %rax
jne 0x8318
callq 0x6e43
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6340
movq %rbx, %rdi
movq %r14, %rsi
callq 0x826b
vcvtusi2sd %r14, %xmm0, %xmm0
testq %r15, %r15
pushq $0x40
popq %rdi
cmovneq %r15, %rdi
movq %r14, %rax
xorl %edx, %edx
divq %rdi
movq %rax, %r13
xorl %r15d, %r15d
cmpq %r14, %rdi
pushq $0x1
popq %r12
cmovaq %r12, %r13
leaq -0x1(%r14), %rax
movq %rax, -0x40(%rbp)
movq %r14, -0x50(%rbp)
movq -0x8(%rbx,%r14,8), %rsi
movq (%rbx), %rcx
subq %rcx, %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movq %rax, %r14
cmpq %rsi, %rdi
cmovaq %r12, %r14
vmovsd 0x9cdd(%rip), %xmm1     # 0x12068
vmovsd %xmm0, -0x30(%rbp)
vdivsd %xmm0, %xmm1, %xmm0
leaq 0x9ec3(%rip), %rsi      # 0x1225e
movq -0x38(%rbp), %rdi
xorl %edx, %edx
movb $0x1, %al
callq 0x6300
movq %r15, %rax
negq %rax
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
cmpq %rsi, %r12
jae 0x840f
leaq (%rax,%r12), %rdx
movq (%rbx,%r12,8), %rcx
cmpq %r13, %rdx
jae 0x83d9
movq %rcx, %rdx
subq (%rbx,%r15,8), %rdx
cmpq %r14, %rdx
jae 0x83d9
incq %r12
jmp 0x83b6
leaq 0x1(%r12), %rax
movq %rax, -0x48(%rbp)
vcvtusi2sd %rax, %xmm2, %xmm0
vmulsd 0x9c78(%rip), %xmm0, %xmm0 # 0x12068
vdivsd -0x30(%rbp), %xmm0, %xmm0
leaq 0x9e62(%rip), %rsi      # 0x1225e
movq %r12, %rdx
movb $0x1, %al
callq 0x6300
movq %r12, %r15
movq -0x48(%rbp), %r12
jmp 0x83a8
movq -0x40(%rbp), %rdx
cmpq %rdx, %r15
je 0x843c
vmovsd -0x30(%rbp), %xmm1
vmulsd 0x9c43(%rip), %xmm1, %xmm0 # 0x12068
vdivsd %xmm1, %xmm0, %xmm0
movq -0x8(%rbx,%rsi,8), %rcx
leaq 0x9e29(%rip), %rsi      # 0x1225e
movb $0x1, %al
callq 0x6300
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6060
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: crc32
inline u32
crc32(const void * const ptr, const size_t size)
{
  const uint8_t * p = (typeof(p))ptr;
  size_t sz = size;

  u32 crc = UINT32_C(0xffffffff);

  while (sz--)
    crc = __crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);

  return crc ^ UINT32_C(0xffffffff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
leaq 0xa230(%rip), %rdx      # 0x12840
cmpq %rcx, %rsi
je 0x862c
movb (%rdi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdx,%r8,4), %eax
incq %rcx
jmp 0x8610
notl %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: xlog_create
struct xlog *
xlog_create(const u64 nr_init, const u64 unit_size)
{
  struct xlog * const xlog = (typeof(xlog))xalloc(64, sizeof(*xlog));
  debug_assert(xlog);
  xlog->nr_rec = 0;
  xlog->nr_cap = nr_init ? nr_init : 4096;
  debug_assert(unit_size);
  xlog->unit_size = unit_size;

  xlog->ptr = malloc(xlog->unit_size * xlog->nr_cap);
  debug_assert(xlog->ptr);
  return xlog;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x40
popq %rdi
pushq $0x20
popq %rsi
callq 0x7b93
movq %rax, %rbx
testq %rax, %rax
jne 0x89b2
callq 0x6e43
andq $0x0, (%rbx)
testq %r15, %r15
movl $0x1000, %edi           # imm = 0x1000
cmovneq %r15, %rdi
movq %rdi, 0x8(%rbx)
testq %r14, %r14
jne 0x89d4
callq 0x6e43
movq 0x8(%rbx), %rdi
movq %r14, 0x10(%rbx)
imulq %r14, %rdi
callq 0x63a0
movq %rax, 0x18(%rbx)
testq %rax, %rax
jne 0x89ef
callq 0x6e43
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: xlog_append
inline void
xlog_append(struct xlog * const xlog, const void * const rec)
{
  if (xlog->nr_rec == xlog->nr_cap) {
    xlog_enlarge(xlog);
  }
  u8 * const ptr = xlog->ptr + (xlog->nr_rec * xlog->unit_size);
  memcpy(ptr, rec, xlog->unit_size);
  xlog->nr_rec++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq 0x8(%rbx), %rdi
jne 0x8a56
leaq (%rdi,%rdi), %rax
movl $0x100000, %ecx         # imm = 0x100000
leaq (%rdi,%rcx), %r12
cmpq %rcx, %rdi
cmovbq %rax, %r12
movq 0x18(%rbx), %rdi
movq 0x10(%rbx), %rsi
imulq %r12, %rsi
callq 0x63f0
movq %rax, %r15
testq %rax, %rax
jne 0x8a49
callq 0x6e43
movq %r15, 0x18(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rdi
jmp 0x8a5a
movq 0x18(%rbx), %r15
movq 0x10(%rbx), %rdx
imulq %rdx, %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0x6340
incq (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: xlog_iter_create
inline struct xlog_iter *
xlog_iter_create(const struct xlog * const xlog)
{
  struct xlog_iter * const iter = (typeof(iter))malloc(sizeof(*iter));
  iter->xlog = xlog;
  iter->next_id = 0;
  return iter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x63a0
movq %rbx, (%rax)
andq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: str10_u32
void
str10_u32(void * const out, const u32 v)
{
  u32 vv = v;
  u16 * const ptr = (typeof(ptr))out;
  for (int i = 4; i >= 0; i--) {
    ptr[i] = __conv_table_10[vv % 100];
    vv /= 100u;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
movl $0x4, %ecx
movl $0x64, %esi
leaq 0x10787(%rip), %r8      # 0x19350
testl %ecx, %ecx
js 0x8be2
xorl %edx, %edx
divl %esi
movzwl (%r8,%rdx,2), %edx
movl %ecx, %r9d
movw %dx, (%rdi,%r9,2)
decl %ecx
jmp 0x8bc9
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: str10_u64
void
str10_u64(void * const out, const u64 v)
{
  u64 vv = v;
  u16 * const ptr = (typeof(ptr))out;
  for (int i = 9; i >= 0; i--) {
    ptr[i] = __conv_table_10[vv % 100];
    vv /= 100;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
movl $0x9, %ecx
leaq 0x10759(%rip), %rsi     # 0x19350
movabsq $0x64, %r8
testl %ecx, %ecx
js 0x8c1a
xorl %edx, %edx
divq %r8
movzwl (%rsi,%rdx,2), %edx
movl %ecx, %r9d
movw %dx, (%rdi,%r9,2)
decl %ecx
jmp 0x8c01
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: string_tokens
char **
string_tokens(const char * const str, const char * const delim)
{
  if (str == NULL) return NULL;
  size_t aptr = 32;
  char ** tokens = (typeof(tokens))malloc(sizeof(tokens[0]) * aptr);
  if (tokens == NULL) return NULL;
  size_t i = 0;
  char * const dup = strdup(str);
  char * internal = NULL;
  const size_t bufsize = strlen(dup) + 1;
  char * tok = strtok_r(dup, delim, &internal);
  while (tok) {
    if (i >= aptr) {
      char ** const r = (typeof(tokens))realloc(tokens, sizeof(tokens[0]) * (aptr + 32));
      if (r == NULL) {
        free(tokens);
        free(dup);
        return NULL;
      }
      tokens = r;
      aptr += 32;
    }
    tokens[i] = tok;
    i++;
    tok = strtok_r(NULL, delim, &internal);
  }
  tokens[i] = tok;
  const size_t nptr = i + 1;
  const size_t rsize = (sizeof(tokens[0]) * nptr) + bufsize;
  char ** const r = (typeof(tokens))realloc(tokens, rsize);
  if (r == NULL) {
    free(tokens);
    free(dup);
    return NULL;
  }
  tokens = r;
  char * const content = (char *)(&(tokens[nptr]));
  memcpy(content, dup, bufsize);
  for (u64 j = 0; j < i; j++) {
    tokens[j] += (content - dup);
  }
  free(dup);
  return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x48(%rbp)
testq %rdi, %rdi
je 0x8d4b
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x63a0
testq %rax, %rax
je 0x8d4b
movq %rax, %r13
movq %rbx, %rdi
callq 0x65b0
movq %rax, %rbx
leaq -0x50(%rbp), %rax
andq $0x0, (%rax)
movq %rbx, %rdi
callq 0x6170
movq %rax, %r12
incq %rax
movq %rax, -0x40(%rbp)
addq $0x9, %r12
movq %rbx, %rax
addq $-0x8, %rax
movq %rax, -0x38(%rbp)
pushq $0x20
popq %r15
xorl %r14d, %r14d
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x6290
testq %rax, %rax
je 0x8d50
movq %rax, %rbx
cmpq %r15, %r14
movq %r13, %rax
jb 0x8d34
leaq 0x100(,%r15,8), %rsi
movq %rax, %r13
movq %rax, %rdi
callq 0x63f0
testq %rax, %rax
je 0x8da5
addq $0x20, %r15
movq %rax, %r13
movq %rbx, (%rax,%r14,8)
incq %r14
addq $0x8, %r12
addq $-0x8, -0x38(%rbp)
xorl %edi, %edi
jmp 0x8cfb
xorl %r15d, %r15d
jmp 0x8dc1
movq %r13, %rbx
andq $0x0, (%r13,%r14,8)
movq %r13, %rdi
movq %r12, %rsi
callq 0x63f0
testq %rax, %rax
je 0x8daa
movq %rax, %r15
leaq (%rax,%r14,8), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rbx
movq %rbx, %rsi
movq -0x40(%rbp), %rdx
callq 0x6340
movq -0x38(%rbp), %rdx
negq %rdx
xorl %eax, %eax
cmpq %rax, %r14
je 0x8db9
movq (%r15,%rax,8), %rcx
addq %r15, %rcx
addq %rdx, %rcx
movq %rcx, (%r15,%rax,8)
incq %rax
jmp 0x8d8d
movq %r13, %rdi
jmp 0x8dad
movq %rbx, %rdi
callq 0x6060
xorl %r15d, %r15d
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x6060
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: damp_create
struct damp *
damp_create(const u64 cap, const double dshort, const double dlong)
{
  struct damp * const d = malloc(sizeof(*d) + (sizeof(d->hist[0]) * cap));
  d->cap = cap;
  d->used = 0;
  d->next = 0;
  d->events = 0;
  d->dshort = dshort;
  d->dlong = dlong;
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
vmovsd %xmm1, -0x18(%rbp)
vmovsd %xmm0, -0x10(%rbp)
movq %rdi, %rbx
leaq 0x30(,%rdi,8), %rdi
callq 0x63a0
movq %rbx, (%rax)
vxorps %xmm0, %xmm0, %xmm0
andq $0x0, 0x18(%rax)
vmovups %xmm0, 0x8(%rax)
vmovsd -0x10(%rbp), %xmm0
vmovsd %xmm0, 0x20(%rax)
vmovsd -0x18(%rbp), %xmm0
vmovsd %xmm0, 0x28(%rax)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: damp_average
double
damp_average(const struct damp * const d)
{
  if (d->used == 0) return 0.0;
  const u64 start = d->next - d->used;
  double sum = 0.0;
  for (u64 i = 0; i < d->used; i++) {
    const u64 idx = (start + i) % d->cap;
    sum += d->hist[idx];
  }
  const double avg = sum / ((double)d->used);
  return avg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x8e65
movq (%rdi), %rsi
movq 0x10(%rdi), %r8
movq %rcx, %r9
negq %r9
vxorpd %xmm0, %xmm0, %xmm0
testq %r9, %r9
je 0x8e59
leaq (%r8,%r9), %rax
xorl %edx, %edx
divq %rsi
vaddsd 0x30(%rdi,%rdx,8), %xmm0, %xmm0
incq %r9
jmp 0x8e40
vcvtusi2sd %rcx, %xmm1, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
jmp 0x8e69
vxorpd %xmm0, %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: damp_min
double
damp_min(const struct damp * const d)
{
  if (d->used == 0) return 0.0;
  const u64 start = d->next - d->used;
  double min = d->hist[start % d->cap];
  for (u64 i = 1; i < d->used; i++) {
    const u64 idx = (start + i) % d->cap;
    const double v = d->hist[idx];
    if (v < min) min = v;
  }
  return min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %r9
testq %r9, %r9
je 0x8eba
movq (%rdi), %rcx
movq 0x10(%rdi), %rsi
movq %rsi, %rax
subq %r9, %rax
xorl %edx, %edx
divq %rcx
vmovsd 0x30(%rdi,%rdx,8), %xmm0
movabsq $0x1, %r8
subq %r9, %r8
testq %r8, %r8
je 0x8ebe
leaq (%rsi,%r8), %rax
xorl %edx, %edx
divq %rcx
vmovsd 0x30(%rdi,%rdx,8), %xmm1
vminsd %xmm0, %xmm1, %xmm0
incq %r8
jmp 0x8e9d
vxorpd %xmm0, %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: damp_max
double
damp_max(const struct damp * const d)
{
  if (d->used == 0) return 0.0;
  const u64 start = d->next - d->used;
  double max = d->hist[start % d->cap];
  for (u64 i = 1; i < d->used; i++) {
    const u64 idx = (start + i) % d->cap;
    const double v = d->hist[idx];
    if (v > max) max = v;
  }
  return max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %r9
testq %r9, %r9
je 0x8f0f
movq (%rdi), %rcx
movq 0x10(%rdi), %rsi
movq %rsi, %rax
subq %r9, %rax
xorl %edx, %edx
divq %rcx
vmovsd 0x30(%rdi,%rdx,8), %xmm0
movabsq $0x1, %r8
subq %r9, %r8
testq %r8, %r8
je 0x8f13
leaq (%rsi,%r8), %rax
xorl %edx, %edx
divq %rcx
vmovsd 0x30(%rdi,%rdx,8), %xmm1
vmaxsd %xmm0, %xmm1, %xmm0
incq %r8
jmp 0x8ef2
vxorpd %xmm0, %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: damp_add_test
bool
damp_add_test(struct damp * const d, const double v)
{
  d->hist[d->next] = v;
  d->next = (d->next + 1) % d->cap;
  if (d->used < d->cap) d->used++;
  d->events++;

  // short-distance history
  const u64 end = d->next - 1;
  if (d->used >= 3) {
    const double v0 = d->hist[(end - 0) % d->cap];
    const double v1 = d->hist[(end - 1) % d->cap];
    const double v2 = d->hist[(end - 2) % d->cap];
    const double dd = v0 * d->dshort;
    const double d01 = fabs(v1 - v0);
    const double d02 = fabs(v2 - v0);
    if (d01 < dd && d02 < dd) {
      return true;
    }
  }

  // full-distance history
  const double avg = damp_average(d);
  const double dev = avg * d->dlong;
  if (d->used == d->cap) {
    double min = d->hist[0];
    double max = min;
    for (u64 i = 1; i < d->cap; i++) {
      if (d->hist[i] < min) min = d->hist[i];
      if (d->hist[i] > max) max = d->hist[i];
    }
    if (fabs(max - min) < dev) {
      return true;
    }
  }

  if (d->events >= (d->cap * 2)) {
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
vmovsd %xmm0, 0x30(%rdi,%rax,8)
incq %rax
movq (%rdi), %r14
movq 0x8(%rdi), %r12
xorl %edx, %edx
divq %r14
movq %rdx, %rcx
movq %rdx, 0x10(%rdi)
cmpq %r14, %r12
jae 0x8f4f
incq %r12
movq %r12, 0x8(%rbx)
movq 0x18(%rbx), %r15
incq %r15
movq %r15, 0x18(%rbx)
cmpq $0x3, %r12
jb 0x8fbf
leaq -0x1(%rcx), %rax
xorl %edx, %edx
divq %r14
vmovsd 0x30(%rbx,%rdx,8), %xmm0
leaq -0x2(%rcx), %rax
xorl %edx, %edx
divq %r14
vmovsd 0x30(%rbx,%rdx,8), %xmm2
vmulsd 0x20(%rbx), %xmm0, %xmm1
vsubsd %xmm0, %xmm2, %xmm2
vandpd 0x90df(%rip){1to2}, %xmm2, %xmm2 # 0x12070
vucomisd %xmm2, %xmm1
jbe 0x8fbf
addq $-0x3, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r14
vmovsd 0x30(%rbx,%rdx,8), %xmm2
vsubsd %xmm0, %xmm2, %xmm0
vandpd 0x90b9(%rip){1to2}, %xmm0, %xmm0 # 0x12070
movb $0x1, %al
vucomisd %xmm0, %xmm1
ja 0x9017
movq %rbx, %rdi
callq 0x8e22
cmpq %r14, %r12
jne 0x900e
vmulsd 0x28(%rbx), %xmm0, %xmm0
vmovsd 0x30(%rbx), %xmm1
pushq $0x7
popq %rax
vmovapd %xmm1, %xmm2
leaq -0x6(%rax), %rcx
cmpq %r14, %rcx
jae 0x8ff8
vmovsd (%rbx,%rax,8), %xmm3
vminsd %xmm1, %xmm3, %xmm1
vmaxsd %xmm2, %xmm3, %xmm2
incq %rax
jmp 0x8fdd
vsubsd %xmm1, %xmm2, %xmm1
vandpd 0x906a(%rip){1to2}, %xmm1, %xmm1 # 0x12070
movb $0x1, %al
vucomisd %xmm1, %xmm0
ja 0x9017
addq %r14, %r14
cmpq %r14, %r15
setae %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: xorshift
inline u64
xorshift(const u64 seed)
{
  u64 x = seed ? seed : time_nsec();
  x ^= x >> 12; // a
  x ^= x << 25; // b
  x ^= x >> 27; // c
  return x * UINT64_C(2685821657736338717);
}

// Assembly:
testq %rdi, %rdi
jne 0x912d
pushq %rbp
movq %rsp, %rbp
callq 0x6c7b
movq %rax, %rdi
popq %rbp
movq %rdi, %rax
shrq $0xc, %rax
xorq %rdi, %rax
movq %rax, %rcx
shlq $0x19, %rcx
xorq %rax, %rcx
movq %rcx, %rdx
shrq $0x1b, %rdx
xorq %rcx, %rdx
movabsq $0x2545f4914f6cdd1d, %rax # imm = 0x2545F4914F6CDD1D
imulq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: rgen_new_exponential
struct rgen *
rgen_new_exponential(const double percentile, const double range)
{
  struct rgen * const gi = (typeof(gi))calloc(1, sizeof(*gi));
  gi->unit_u64 = true;
  gi->gen.exponential.gamma = - log(1.0 - (percentile/100.0)) / range;

  gi->type = GEN_EXPONENTIAL;
  gi->next_wait = gen_exponential;
  gi->next_nowait = gen_exponential;
  return gi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
vmovsd %xmm1, -0x18(%rbp)
vmovsd %xmm0, -0x10(%rbp)
pushq $0x1
popq %rdi
movl $0x220, %esi            # imm = 0x220
callq 0x62d0
movq %rax, %rbx
movb $0x1, 0x14(%rax)
vmovsd -0x10(%rbp), %xmm0
vdivsd 0x8ecd(%rip), %xmm0, %xmm0 # 0x12088
vaddsd 0x8eb5(%rip), %xmm0, %xmm0 # 0x12078
callq 0x6240
vxorpd 0x8ebe(%rip){1to2}, %xmm0, %xmm0 # 0x12090
vdivsd -0x18(%rbp), %xmm0, %xmm0
vmovsd %xmm0, 0x18(%rbx)
movl $0x7, 0x10(%rbx)
leaq 0x11(%rip), %rax        # 0x91fb
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq