LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %r10
testq %r10, %r10
je 0x7a5a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
rorxq $0x21, %rsi, %rcx
movq 0x8(%rdi), %r8
xorl %r9d, %r9d
movl $0x1, %r11d
movq %rsi, %rax
xorl %edx, %edx
divq (%r8)
movq %rdx, %rax
shrq $0x6, %rax
movq 0x10(%r8,%rax,8), %rbx
btq %rdx, %rbx
jb 0x7a4d
shlxq %rdx, %r11, %rdx
orq %rbx, %rdx
movq %rdx, 0x10(%r8,%rax,8)
lock
incq 0x8(%r8)
movq (%rdi), %r10
addq %rcx, %rsi
incq %r9
cmpq %r10, %r9
jb 0x7a1e
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x7ac9
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rdi
movq (%rdi), %r8
movq %rsi, %rax
xorl %edx, %edx
divq %r8
xorl %eax, %eax
movq %rdx, %r9
shrq $0x6, %r9
movq 0x10(%rdi,%r9,8), %r9
btq %rdx, %r9
jae 0x7ac7
rorxq $0x21, %rsi, %r9
addq %r9, %rsi
movl $0x1, %eax
movq %rax, %r10
cmpq %rax, %rcx
je 0x7ac1
movq %rsi, %rax
xorl %edx, %edx
divq %r8
movq %rdx, %rax
shrq $0x6, %rax
movq 0x10(%rdi,%rax,8), %r11
addq %r9, %rsi
leaq 0x1(%r10), %rax
btq %rdx, %r11
jb 0x7a98
cmpq %rcx, %r10
setae %al
popq %rbp
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc738(%rip), %rdi      # 0x14238
leaq 0xc705(%rip), %rsi      # 0x1420c
callq 0x6480
testq %rax, %rax
je 0x7b57
movq %rax, %r14
leaq 0xc72e(%rip), %rsi      # 0x14249
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 0x7b59
movq -0x20(%rbp), %r14
movl $0x1e, %edi
callq 0x64a0
movq %rax, %rbx
imulq %r14, %rbx
jmp 0x7b59
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x53, %edi
callq 0x64a0
cltq
addq $0x3f, %rax
shrq $0x3, %rax
andq $-0x8, %rax
cmpq $0x81, %rax
movl $0x80, %ebx
cmovaeq %rax, %rbx
movq %rbx, %rdi
callq 0x63a0
movq %rax, %r14
xorl %edi, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x6580
testl %eax, %eax
je 0x7bbf
movl $0x53, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x64a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6150
movl %eax, %ebx
movq %r14, %rdi
callq 0x6060
testl %ebx, %ebx
jle 0x7bb1
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%rdi,8), %rdx
xorl %r15d, %r15d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x6210
movl $0x53, %edi
callq 0x64a0
cltq
addq $0x3f, %rax
shrq $0x3, %rax
andq $-0x8, %rax
cmpq $0x81, %rax
movl $0x80, %r13d
cmovaeq %rax, %r13
movq %r13, %rdi
callq 0x63a0
movq %rax, %r12
xorl %edi, %edi
movq %r13, %rsi
movq %rax, %rdx
callq 0x6580
testl %eax, %eax
jne 0x7cdb
movq %rbx, -0x30(%rbp)
movl $0x53, %edi
callq 0x64a0
movq %rax, %rbx
movq %r13, %rdi
movq %r12, %rsi
callq 0x6150
cltq
cmpq %r14, %rax
cmovbq %rax, %r14
testq %rbx, %rbx
je 0x7cd0
decq %rbx
xorl %eax, %eax
movabsq $0x100000000, %rcx      # imm = 0x100000000
xorl %edx, %edx
xorl %r15d, %r15d
movq -0x30(%rbp), %r8
movq %rax, %rsi
sarq $0x20, %rsi
movq %rsi, %rdi
shrq $0x3, %rdi
cmpq %r13, %rdi
jae 0x7cba
shrq $0x6, %rsi
movq (%r12,%rsi,8), %rsi
btq %rdx, %rsi
jae 0x7cba
movq %rdx, (%r8,%r15,8)
incq %r15
cmpq %r14, %r15
jae 0x7cd3
leaq 0x1(%rdx), %rsi
addq %rcx, %rax
cmpq %rdx, %rbx
movq %rsi, %rdx
jne 0x7c92
jmp 0x7cd3
xorl %r15d, %r15d
movq %r12, %rdi
callq 0x6060
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x53, %edi
callq 0x64a0
movq %rax, %r15
movl $0x53, %edi
callq 0x64a0
cltq
addq $0x3f, %rax
shrq $0x3, %rax
andq $-0x8, %rax
cmpq $0x81, %rax
movl $0x80, %ebx
cmovaeq %rax, %rbx
movl $0x1, %r13d
movl $0x1, %edi
movq %rbx, %rsi
callq 0x62d0
movq %rax, %r12
movq %r14, %rax
xorl %edx, %edx
divq %r15
movq %rdx, %rax
shrq $0x3, %rax
cmpq %rbx, %rax
jae 0x7da9
shlxq %rdx, %r13, %rax
shrq $0x6, %rdx
orq %rax, (%r12,%rdx,8)
xorl %edi, %edi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x6250
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6060
// File: /workspace/github_c_makefile_star2_O3/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
je 0x8097
movq %rsp, %rdx
leaq 0xf(,%rdi,8), %rax
andq $-0x10, %rax
subq %rax, %rdx
movq %rdx, %rsp
jmp 0x80b9
callq 0x7b67
movq %rax, %rdi
movq %rsp, %rdx
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %rdx
movq %rdx, %rsp
testq %rdi, %rdi
je 0x80d8
xorl %eax, %eax
movq %r14, (%rdx,%rax,8)
incq %rax
cmpq %rax, %rdi
jne 0x80bb
movq %rbx, %rsi
callq 0x7dcc
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %edi, %edi
jmp 0x80c7
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
testl %esi, %esi
je 0x82fe
leaq 0x3fffffff(%r15), %r14
andq $-0x40000000, %r14      # imm = 0xC0000000
movq %r14, %rax
subq %r15, %rax
movq %r15, %rcx
shrq $0x4, %rcx
cmpq %rcx, %rax
jae 0x82fe
xorl %edi, %edi
movq %r14, %rsi
movl $0x3, %edx
movl $0x78042022, %ecx       # imm = 0x78042022
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x6190
movq %rax, %r12
incq %rax
cmpq $0x1, %rax
ja 0x837c
cmpq $0x100000, %r15         # imm = 0x100000
jb 0x833e
leaq 0x1fffff(%r15), %r14
andq $-0x200000, %r14        # imm = 0xFFE00000
xorl %edi, %edi
movq %r14, %rsi
movl $0x3, %edx
movl $0x54042022, %ecx       # imm = 0x54042022
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x6190
movq %rax, %r12
incq %rax
cmpq $0x1, %rax
ja 0x837c
addq $0xfff, %r15            # imm = 0xFFF
movq %r15, %r14
andq $-0x1000, %r14          # imm = 0xF000
xorl %r12d, %r12d
xorl %edi, %edi
movq %r14, %rsi
movl $0x3, %edx
movl $0x2022, %ecx           # imm = 0x2022
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x6190
leaq 0x1(%rax), %rcx
cmpq $0x2, %rcx
jb 0x837f
movq %rax, %r12
movq %r14, (%rbx)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %edi
movl $0x15f90, %esi          # imm = 0x15F90
callq 0x62d0
movq %rax, %rbx
movq %rax, %rdi
movl $0x1, %esi
callq 0x62e0
movl $0x1f90, %r14d          # imm = 0x1F90
leaq (%rbx,%r14), %rdi
movl $0x1, %esi
callq 0x62e0
addq $0x50, %r14
cmpq $0x15f90, %r14          # imm = 0x15F90
jne 0x83b7
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:-0x8, %rax
testq %rax, %rax
jne 0x841b
leaq -0x38(%rbp), %r15
movl $0x4, %edi
movq %r15, %rsi
callq 0x6110
imulq $0x3b9aca00, (%r15), %rax # imm = 0x3B9ACA00
addq 0x8(%r15), %rax
movq %rax, %rcx
shrq $0xc, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shlq $0x19, %rax
xorq %rcx, %rax
movq %rax, %rcx
shrq $0x1b, %rcx
xorq %rax, %rcx
movabsq $0x2545f4914f6cdd1d, %rax # imm = 0x2545F4914F6CDD1D
imulq %rcx, %rax
movq %rax, %fs:-0x8
andl $0x3ff, %eax            # imm = 0x3FF
leaq (%rax,%rax,4), %rax
shll $0x4, %eax
leaq (%r14,%rax), %r15
addq $0x1f90, %r15           # imm = 0x1F90
movq %r15, %rdi
callq 0x6050
cmpl $0x23, %eax
je 0x857b
addq $0x7, %rbx
andq $-0x8, %rbx
movq 0x40(%r15), %r12
testq %r12, %r12
je 0x849e
movq 0x48(%r15), %rax
leaq (%rax,%rbx), %rcx
cmpq $0x40001, %rcx          # imm = 0x40001
jb 0x8546
movq %r14, %rdi
callq 0x6050
cmpl $0x23, %eax
je 0x857b
movq 0x40(%r14), %r13
movq 0x48(%r14), %r12
cmpq $0x1000, %r12           # imm = 0x1000
jb 0x84d2
incq %r13
movq %r13, 0x40(%r14)
movq $0x0, 0x48(%r14)
xorl %r12d, %r12d
cmpq $0x3e7, %r13            # imm = 0x3E7
jbe 0x84e0
xorl %r12d, %r12d
jmp 0x852b
movq 0x50(%r14,%r13,8), %rax
movq %r12, %rcx
testq %rax, %rax
jne 0x851d
leaq -0x38(%rbp), %rdx
movq $0x0, (%rdx)
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x1, %esi
callq 0x82a0
movq %rax, 0x50(%r14,%r13,8)
leaq -0x38(%rbp), %rcx
cmpq $0x40000000, (%rcx)     # imm = 0x40000000
jne 0x856f
movq 0x48(%r14), %rcx
shlq $0x12, %r12
addq %rax, %r12
incq %rcx
movq %rcx, 0x48(%r14)
movq %r14, %rdi
callq 0x6320
movq %r12, 0x40(%r15)
movq $0x0, 0x48(%r15)
xorl %eax, %eax
testq %r12, %r12
je 0x8552
addq %rax, %r12
addq %rax, %rbx
movq %rbx, 0x48(%r15)
jmp 0x8555
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x6320
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x66ef
movq 0x50(%r14,%r13,8), %rax
jmp 0x8519
xorl %edi, %edi
callq 0x6530
// File: /workspace/github_c_makefile_star2_O3/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
movl $0xa, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x8614
movl $0x40000000, %esi       # imm = 0x40000000
callq 0x6410
incq %r14
cmpq $0x3f2, %r14            # imm = 0x3F2
jne 0x8601
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6060
// File: /workspace/github_c_makefile_star2_O3/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
movq %rax, %r14
xorl %eax, %eax
addq %rcx, %rsi
jb 0x87ac
cmpq 0x800(%rdi), %r14
jae 0x87ac
shlq $0x8, %r14
movq %fs:-0x8, %rax
testq %rax, %rax
jne 0x8703
leaq -0x40(%rbp), %r15
movq %rdi, %rbx
movl $0x4, %edi
movq %r15, %rsi
callq 0x6110
movq %rbx, %rdi
imulq $0x3b9aca00, (%r15), %rax # imm = 0x3B9ACA00
addq 0x8(%r15), %rax
leaq (%rdi,%r14), %r15
addq $0x810, %r15            # imm = 0x810
movq %rax, %rcx
shrq $0xc, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shlq $0x19, %rax
xorq %rcx, %rax
movq %rax, %rcx
shrq $0x1b, %rcx
xorq %rax, %rcx
movabsq $0x2545f4914f6cdd1d, %rax # imm = 0x2545F4914F6CDD1D
imulq %rcx, %rax
movq %rax, -0x30(%rbp)
movq %rax, %fs:-0x8
xorl %ebx, %ebx
movq -0x30(%rbp), %rax
leal (%rax,%rbx), %r13d
andl $0x1f, %r13d
cmpq $0x0, (%r15,%r13,8)
je 0x878a
movl %r13d, %r14d
shll $0x6, %r14d
movq %rdi, %r12
addq %rdi, %r14
movq %r14, %rdi
callq 0x6050
cmpl $0x23, %eax
je 0x87bb
movq (%r15,%r13,8), %rax
testq %rax, %rax
jne 0x8797
movq %r14, %rdi
callq 0x6320
movq %r12, %rdi
incq %rbx
cmpq $0x20, %rbx
jne 0x8749
xorl %eax, %eax
jmp 0x87ac
movq %rax, %rbx
movq (%rax), %rax
movq %rax, (%r15,%r13,8)
movq %r14, %rdi
callq 0x6320
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x6530
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdx, %r8
movq %rdi, %r14
movq 0x808(%rdi), %rdi
leaq (%rsi,%rdi), %rcx
decq %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
movq %rax, %r12
cmpq 0x800(%r14), %rax
setb %al
cmpq %rcx, %rdi
setbe %r15b
andb %al, %r15b
cmpb $0x1, %r15b
jne 0x88b3
movq %r8, -0x30(%rbp)
movq %fs:-0x8, %rax
testq %rax, %rax
jne 0x883f
leaq -0x40(%rbp), %r13
movl $0x4, %edi
movq %r13, %rsi
callq 0x6110
imulq $0x3b9aca00, (%r13), %rax # imm = 0x3B9ACA00
addq 0x8(%r13), %rax
movq %rax, %rcx
shrq $0xc, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shlq $0x19, %rax
xorq %rcx, %rax
movq %rax, %rcx
shrq $0x1b, %rcx
xorq %rax, %rcx
movabsq $0x2545f4914f6cdd1d, %r13 # imm = 0x2545F4914F6CDD1D
imulq %rcx, %r13
movq %r13, %fs:-0x8
andl $0x1f, %r13d
movl %r13d, %ebx
shll $0x6, %ebx
addq %r14, %rbx
movq %rbx, %rdi
callq 0x6050
cmpl $0x23, %eax
je 0x88c5
shlq $0x8, %r12
leaq (%r14,%r12), %rax
addq $0x810, %rax            # imm = 0x810
movq (%rax,%r13,8), %rcx
movq -0x30(%rbp), %rdx
movq %rcx, (%rdx)
movq %rdx, (%rax,%r13,8)
movq %rbx, %rdi
callq 0x6320
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x6530
// File: /workspace/github_c_makefile_star2_O3/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
leaq (%rbx,%r14), %rdi
callq 0x6050
cmpl $0x23, %eax
je 0x8978
addq $0x40, %r14
cmpq $0x800, %r14            # imm = 0x800
jne 0x88d9
cmpq $0x1, 0x800(%rbx)
jbe 0x8957
leaq 0x910(%rbx), %rax
movl $0x1, %ecx
vxorps %xmm0, %xmm0, %xmm0
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
cmpq 0x800(%rbx), %rcx
jb 0x8912
xorl %r14d, %r14d
leaq (%rbx,%r14), %rdi
vzeroupper
callq 0x6320
addq $0x40, %r14
cmpq $0x800, %r14            # imm = 0x800
jne 0x895a
popq %rbx
popq %r14
popq %rbp
retq
xorl %edi, %edi
callq 0x6530
// File: /workspace/github_c_makefile_star2_O3/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 0x8a2e
movq 0x18(%rdi), %rax
testq %rax, %rax
jne 0x8a25
leaq 0x810(%rcx), %rsi
movq 0x10(%rdi), %r8
incq %r8
movq %r8, 0x10(%rdi)
cmpq $0x20, %r8
jb 0x8a05
incq %rdx
movq %rdx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
xorl %r8d, %r8d
cmpq 0x800(%rcx), %rdx
jae 0x8a2e
movq %rdx, %rax
shlq $0x8, %rax
addq %rsi, %rax
movq (%rax,%r8,8), %rax
movq %rax, 0x18(%rdi)
testq %rax, %rax
je 0x89e6
movq (%rax), %rcx
movq %rcx, 0x18(%rdi)
jmp 0x8a30
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x100, %rcx            # imm = 0x100
jl 0x8a9c
clflush (%rdi)
clflush 0x40(%rdi)
clflush 0x80(%rdi)
clflush 0xc0(%rdi)
addq $0x100, %rdi            # imm = 0x100
addq $-0x100, %rcx
cmpq $0xff, %rcx
jg 0x8a67
jmp 0x8a9c
clflush (%rdi)
addq $0x40, %rdi
cmpq %rax, %rdi
jbe 0x8a95
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, -0x30(%rbp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
leaq (,%rsi,8), %r15
movq %r15, %rdi
callq 0x63a0
movq %rax, %rbx
testq %rax, %rax
je 0x8cfc
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x6340
leaq -0xa1(%rip), %rcx       # 0x8b1e
movl $0x8, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x60d0
vcvtusi2sd %r12, %xmm0, %xmm0
testq %r14, %r14
movl $0x40, %edi
cmovneq %r14, %rdi
movq %r12, %rax
xorl %edx, %edx
divq %rdi
movq %rax, %r13
xorl %r15d, %r15d
cmpq %r12, %rdi
movl $0x1, %r14d
cmovaq %r14, %r13
leaq -0x1(%r12), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbx,%r12,8), %rsi
movq (%rbx), %rcx
subq %rcx, %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
cmpq %rsi, %rdi
cmovaq %r14, %rax
movq %rax, -0x48(%rbp)
vmovsd 0xb43d(%rip), %xmm1     # 0x14068
vmovsd %xmm0, -0x38(%rbp)
vdivsd %xmm0, %xmm1, %xmm0
leaq 0xb623(%rip), %rsi      # 0x1425e
movq -0x30(%rbp), %rdi
xorl %edx, %edx
movb $0x1, %al
callq 0x6300
cmpq $0x2, %r12
movq %r12, %rsi
jb 0x8cb5
xorl %r15d, %r15d
movq %r14, %rax
subq %r15, %rax
movq (%rbx,%r14,8), %rcx
cmpq %r13, %rax
jae 0x8c78
movq %rcx, %rax
subq (%rbx,%r15,8), %rax
cmpq -0x48(%rbp), %rax
jae 0x8c78
incq %r14
movq %r14, %r12
jmp 0x8cb0
leaq 0x1(%r14), %r12
vcvtusi2sd %r12, %xmm2, %xmm0
vmulsd 0xb3de(%rip), %xmm0, %xmm0 # 0x14068
vdivsd -0x38(%rbp), %xmm0, %xmm0
movq -0x30(%rbp), %rdi
movq %rsi, %r15
leaq 0xb5c1(%rip), %rsi      # 0x1425e
movq %r14, %rdx
movb $0x1, %al
callq 0x6300
movq %r15, %rsi
movq %r14, %r15
movq %r12, %r14
cmpq %rsi, %r12
jne 0x8c54
movq -0x40(%rbp), %rdx
cmpq %rdx, %r15
je 0x8ce6
vmovsd -0x38(%rbp), %xmm1
vmulsd 0xb39d(%rip), %xmm1, %xmm0 # 0x14068
vdivsd %xmm1, %xmm0, %xmm0
movq -0x8(%rbx,%rsi,8), %rcx
leaq 0xb583(%rip), %rsi      # 0x1425e
movq -0x30(%rbp), %rdi
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
callq 0x66ef
jmp 0x8baa
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0x8f22
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
leaq 0xb93c(%rip), %rdx      # 0x14840
movb (%rdi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdx,%r8,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x8f04
notl %eax
jmp 0x8f24
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/./xxhash.h
// Function: xxhash32
XXH_FORCE_INLINE XXH_PUREF xxh_u32
XXH32_endian_align(const xxh_u8* input, size_t len, xxh_u32 seed, XXH_alignment align)
{
    xxh_u32 h32;

    if (input==NULL) XXH_ASSERT(len == 0);

    if (len>=16) {
        xxh_u32 acc[4];
        XXH32_initAccs(acc, seed);

        input = XXH32_consumeLong(acc, input, len, align);

        h32 = XXH32_mergeAccs(acc);
    } else {
        h32  = seed + XXH_PRIME32_5;
    }

    h32 += (xxh_u32)len;

    return XXH32_finalize(h32, input, len&15, align);
}

// Assembly:
testq %rdi, %rdi
je 0x903a
pushq %rbp
movq %rsp, %rbp
movl $0x165667b1, %eax       # imm = 0x165667B1
cmpq $0x10, %rsi
jb 0x8fe3
leaq (%rdi,%rsi), %rdx
addq $-0xf, %rdx
movl $0x24234428, %r9d       # imm = 0x24234428
movl $0x85ebca77, %r8d       # imm = 0x85EBCA77
xorl %ecx, %ecx
movl $0x61c8864f, %eax       # imm = 0x61C8864F
imull $0x85ebca77, (%rdi), %r10d # imm = 0x85EBCA77
addl %r9d, %r10d
rorxl $0x13, %r10d, %r9d
imull $0x9e3779b1, %r9d, %r9d # imm = 0x9E3779B1
imull $0x85ebca77, 0x4(%rdi), %r10d # imm = 0x85EBCA77
addl %r8d, %r10d
rorxl $0x13, %r10d, %r8d
imull $0x9e3779b1, %r8d, %r8d # imm = 0x9E3779B1
imull $0x85ebca77, 0x8(%rdi), %r10d # imm = 0x85EBCA77
addl %ecx, %r10d
rorxl $0x13, %r10d, %ecx
imull $0x9e3779b1, %ecx, %ecx # imm = 0x9E3779B1
imull $0x85ebca77, 0xc(%rdi), %r10d # imm = 0x85EBCA77
addl %eax, %r10d
rorxl $0x13, %r10d, %eax
imull $0x9e3779b1, %eax, %eax # imm = 0x9E3779B1
addq $0x10, %rdi
cmpq %rdx, %rdi
jb 0x8f5d
rorxl $0x1f, %r9d, %edx
rorxl $0x19, %r8d, %r8d
addl %edx, %r8d
rorxl $0x14, %ecx, %ecx
rorxl $0xe, %eax, %eax
addl %ecx, %eax
addl %r8d, %eax
addl %esi, %eax
andl $0xf, %esi
cmpq $0x4, %rsi
jb 0x9010
imull $0xc2b2ae3d, (%rdi), %ecx # imm = 0xC2B2AE3D
addl %eax, %ecx
addq $0x4, %rdi
rorxl $0xf, %ecx, %eax
imull $0x27d4eb2f, %eax, %eax # imm = 0x27D4EB2F
addq $-0x4, %rsi
cmpq $0x3, %rsi
ja 0x8fee
testq %rsi, %rsi
je 0x9037
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %edx
imull $0x165667b1, %edx, %edx # imm = 0x165667B1
addl %eax, %edx
rorxl $0x15, %edx, %eax
imull $0x9e3779b1, %eax, %eax # imm = 0x9E3779B1
incq %rcx
cmpq %rcx, %rsi
jne 0x9017
popq %rbp
jmp 0x903f
movl $0x165667b1, %eax       # imm = 0x165667B1
movl %eax, %ecx
shrl $0xf, %ecx
xorl %eax, %ecx
imull $0x85ebca77, %ecx, %eax # imm = 0x85EBCA77
movl %eax, %ecx
shrl $0xd, %ecx
xorl %eax, %ecx
imull $0xc2b2ae3d, %ecx, %ecx # imm = 0xC2B2AE3D
movl %ecx, %eax
shrl $0x10, %eax
xorl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rdi, %r15
leaq -0x20(%rbp), %rdi
movl $0x40, %esi
movl $0x20, %edx
callq 0x6570
testl %eax, %eax
jne 0x92a9
movq -0x20(%rbp), %r14
jmp 0x92ac
xorl %r14d, %r14d
testq %r14, %r14
je 0x92f1
movq $0x0, (%r14)
testq %r15, %r15
movl $0x1000, %edi           # imm = 0x1000
cmovneq %r15, %rdi
movq %rdi, 0x8(%r14)
testq %rbx, %rbx
je 0x92f8
movq %rbx, 0x10(%r14)
imulq %rbx, %rdi
callq 0x63a0
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x9303
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x66ef
jmp 0x92b1
callq 0x66ef
movq 0x8(%r14), %rdi
jmp 0x92cd
callq 0x66ef
jmp 0x92e3
// File: /workspace/github_c_makefile_star2_O3/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 0x935e
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
je 0x9381
movq %r15, 0x18(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rdi
jmp 0x9362
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
callq 0x66ef
jmp 0x9351
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: xlog_iter_next
inline bool
xlog_iter_next(struct xlog_iter * const iter, void * const out)
{
  const struct xlog * const xlog = iter->xlog;
  if (iter->next_id < xlog->nr_rec) {
    void * const ptr = xlog->ptr + (xlog->unit_size * iter->next_id);
    memcpy(out, ptr, xlog->unit_size);
    iter->next_id++;
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %r14
movq (%rcx), %r15
cmpq %r15, %r14
jae 0x94d6
movq %rdi, %rbx
movq 0x10(%rcx), %rdx
movq %rdx, %rax
imulq %r14, %rax
addq 0x18(%rcx), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x6340
incq 0x8(%rbx)
cmpq %r15, %r14
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
testq %rdi, %rdi
je 0x96c4
movq %rsi, %r12
movq %rdi, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x63a0
testq %rax, %rax
je 0x96c4
movq %rax, %r14
movq %rbx, %rdi
callq 0x65b0
movq %rax, %r15
leaq -0x40(%rbp), %rbx
movq $0x0, (%rbx)
movq %rax, %rdi
callq 0x6170
movq %rax, -0x38(%rbp)
movq %r15, -0x30(%rbp)
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x6290
testq %rax, %rax
je 0x96c9
movq %rax, %rbx
movl $0x20, %r13d
xorl %r15d, %r15d
cmpq %r13, %r15
jb 0x96a5
leaq 0x100(,%r13,8), %rsi
movq %r14, %rdi
callq 0x63f0
testq %rax, %rax
je 0x9728
addq $0x20, %r13
movq %rax, %r14
movq %rbx, (%r14,%r15,8)
incq %r15
xorl %edi, %edi
movq %r12, %rsi
leaq -0x40(%rbp), %rdx
callq 0x6290
movq %rax, %rbx
testq %rax, %rax
jne 0x9680
jmp 0x96cc
xorl %r12d, %r12d
jmp 0x973f
xorl %r15d, %r15d
movq -0x38(%rbp), %r13
incq %r13
movq $0x0, (%r14,%r15,8)
leaq 0x8(,%r15,8), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x63f0
testq %rax, %rax
je 0x9728
movq %rax, %r12
leaq 0x1(%r15), %rax
leaq (%r12,%rax,8), %rbx
movq %rbx, %rdi
movq -0x30(%rbp), %r14
movq %r14, %rsi
movq %r13, %rdx
callq 0x6340
testq %r15, %r15
je 0x9737
subq %r14, %rbx
xorl %eax, %eax
addq %rbx, (%r12,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x971a
jmp 0x9737
movq %r14, %rdi
callq 0x6060
xorl %r12d, %r12d
movq -0x30(%rbp), %r14
movq %r14, %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_O3/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 0x97e1
movq (%rdi), %rsi
movq 0x10(%rdi), %r8
movq %rcx, %r9
negq %r9
vxorpd %xmm0, %xmm0, %xmm0
leaq (%r8,%r9), %rax
xorl %edx, %edx
divq %rsi
vaddsd 0x30(%rdi,%rdx,8), %xmm0, %xmm0
incq %r9
jne 0x97c1
vcvtusi2sd %rcx, %xmm1, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
jmp 0x97e5
vxorpd %xmm0, %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9835
movq (%rdi), %rcx
movq 0x10(%rdi), %rsi
movq %rsi, %rax
subq %r9, %rax
xorl %edx, %edx
divq %rcx
vmovsd 0x30(%rdi,%rdx,8), %xmm0
cmpq $0x1, %r9
je 0x9839
movl $0x1, %r8d
subq %r9, %r8
leaq (%rsi,%r8), %rax
xorl %edx, %edx
divq %rcx
vmovsd 0x30(%rdi,%rdx,8), %xmm1
vminsd %xmm0, %xmm1, %xmm0
incq %r8
jne 0x981b
jmp 0x9839
vxorpd %xmm0, %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9889
movq (%rdi), %rcx
movq 0x10(%rdi), %rsi
movq %rsi, %rax
subq %r9, %rax
xorl %edx, %edx
divq %rcx
vmovsd 0x30(%rdi,%rdx,8), %xmm0
cmpq $0x1, %r9
je 0x988d
movl $0x1, %r8d
subq %r9, %r8
leaq (%rsi,%r8), %rax
xorl %edx, %edx
divq %rcx
vmovsd 0x30(%rdi,%rdx,8), %xmm1
vmaxsd %xmm0, %xmm1, %xmm0
incq %r8
jne 0x986f
jmp 0x988d
vxorpd %xmm0, %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x10(%rdi), %rax
vmovsd %xmm0, 0x30(%rdi,%rax,8)
incq %rax
movq (%rdi), %rsi
movq 0x8(%rdi), %r9
xorl %edx, %edx
divq %rsi
movq %rdx, %rcx
movq %rdx, 0x10(%rdi)
cmpq %rsi, %r9
jae 0x98bb
incq %r9
movq %r9, 0x8(%rdi)
movq 0x18(%rdi), %r8
incq %r8
movq %r8, 0x18(%rdi)
cmpq $0x3, %r9
jb 0x9929
leaq -0x1(%rcx), %rax
xorl %edx, %edx
divq %rsi
vmovsd 0x30(%rdi,%rdx,8), %xmm0
leaq -0x2(%rcx), %rax
xorl %edx, %edx
divq %rsi
vmovsd 0x30(%rdi,%rdx,8), %xmm2
vmulsd 0x20(%rdi), %xmm0, %xmm1
vsubsd %xmm0, %xmm2, %xmm2
vandpd 0xa773(%rip){1to2}, %xmm2, %xmm2 # 0x14070
vucomisd %xmm2, %xmm1
jbe 0x992e
leaq -0x3(%rcx), %rax
xorl %edx, %edx
divq %rsi
vmovsd 0x30(%rdi,%rdx,8), %xmm2
vsubsd %xmm0, %xmm2, %xmm0
vandpd 0xa750(%rip){1to2}, %xmm0, %xmm0 # 0x14070
movb $0x1, %al
vucomisd %xmm0, %xmm1
jbe 0x992e
retq
testq %r9, %r9
je 0x995e
subq %r9, %rcx
vxorpd %xmm0, %xmm0, %xmm0
xorl %r10d, %r10d
movq %r9, %r11
leaq (%rcx,%r10), %rax
xorl %edx, %edx
divq %rsi
vaddsd 0x30(%rdi,%rdx,8), %xmm0, %xmm0
incq %r10
decq %r11
jne 0x993b
vcvtusi2sd %r9, %xmm3, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
jmp 0x9962
vxorpd %xmm0, %xmm0, %xmm0
cmpq %rsi, %r9
jne 0x99bc
vmulsd 0x28(%rdi), %xmm0, %xmm0
vmovsd 0x30(%rdi), %xmm1
cmpq $0x2, %rsi
jb 0x9999
leaq -0x1(%rsi), %rax
xorl %ecx, %ecx
vmovapd %xmm1, %xmm2
vmovsd 0x38(%rdi,%rcx,8), %xmm3
vminsd %xmm2, %xmm3, %xmm2
vmaxsd %xmm1, %xmm3, %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0x9981
jmp 0x999d
vmovapd %xmm1, %xmm2
pushq %rbp
movq %rsp, %rbp
vsubsd %xmm2, %xmm1, %xmm1
vandpd 0xa6c1(%rip){1to2}, %xmm1, %xmm1 # 0x14070
movb $0x1, %al
vucomisd %xmm1, %xmm0
popq %rbp
ja 0x9928
addq %rsi, %rsi
cmpq %rsi, %r8
setae %al
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movl $0x1, %edi
movl $0x220, %esi            # imm = 0x220
callq 0x62d0
movq %rax, %rbx
movb $0x1, 0x14(%rax)
vmovsd -0x10(%rbp), %xmm0
vdivsd 0xa442(%rip), %xmm0, %xmm0 # 0x14088
vaddsd 0xa42a(%rip), %xmm0, %xmm0 # 0x14078
callq 0x6240
vxorpd 0xa433(%rip){1to2}, %xmm0, %xmm0 # 0x14090
vdivsd -0x18(%rbp), %xmm0, %xmm0
vmovsd %xmm0, 0x18(%rbx)
movl $0x7, 0x10(%rbx)
leaq 0x11(%rip), %rax        # 0x9c86
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: rgen_new_constant
struct rgen *
rgen_new_constant(const u64 constant)
{
  struct rgen * const gi = (typeof(gi))calloc(1, sizeof(*gi));
  gi->unit_u64 = constant > UINT32_MAX ? true : false;
  gi->gen.constant.constant = constant;

  gi->type = GEN_CONSTANT;
  gi->next_wait = gen_constant;
  gi->next_nowait = gen_constant;
  return gi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x220, %esi            # imm = 0x220
callq 0x62d0
movq %rbx, %rcx
shrq $0x20, %rcx
setne 0x14(%rax)
movq %rbx, 0x18(%rax)
leaq 0xe(%rip), %rcx         # 0x9d60
movq %rcx, (%rax)
movq %rcx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: rgen_new_counter
struct rgen *
rgen_new_counter(const u64 min, const u64 max)
{
  struct rgen * const gi = (typeof(gi))calloc(1, sizeof(*gi));
  gi->unit_u64 = max > UINT32_MAX ? true : false;
  gi->gen.counter.counter = 0;
  gi->gen.counter.base = min;
  gi->gen.counter.modulus = max - min + 1;

  gi->type = GEN_COUNTER;
  gi->next_wait = gen_counter;
  gi->next_nowait = gen_counter;
  return gi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x220, %esi            # imm = 0x220
callq 0x62d0
movq %rbx, %rcx
shrq $0x20, %rcx
setne 0x14(%rax)
xorl %ecx, %ecx
xchgq %rcx, 0x18(%rax)
movq %r14, 0x20(%rax)
subq %r14, %rbx
incq %rbx
movq %rbx, 0x28(%rax)
movl $0x1, 0x10(%rax)
leaq 0xc(%rip), %rcx         # 0x9dbf
movq %rcx, (%rax)
movq %rcx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: rgen_new_counter_unsafe
struct rgen *
rgen_new_counter_unsafe(const u64 min, const u64 max)
{
  struct rgen * const gi = (typeof(gi))calloc(1, sizeof(*gi));
  gi->unit_u64 = max > UINT32_MAX ? true : false;
  gi->gen.counter.counter_unsafe = 0;
  gi->gen.counter.base = min;
  gi->gen.counter.modulus = max - min + 1;

  gi->type = GEN_COUNTER_UNSAFE;
  gi->next_wait = gen_counter_unsafe;
  gi->next_nowait = gen_counter_unsafe;
  return gi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x220, %esi            # imm = 0x220
callq 0x62d0
movq %rbx, %rcx
shrq $0x20, %rcx
setne 0x14(%rax)
movq %r14, 0x20(%rax)
subq %r14, %rbx
incq %rbx
movq %rbx, 0x28(%rax)
movl $0x2, 0x10(%rax)
leaq 0xc(%rip), %rcx         # 0x9e2c
movq %rcx, (%rax)
movq %rcx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: rgen_new_skipinc_unsafe
struct rgen *
rgen_new_skipinc_unsafe(const u64 min, const u64 max, const u64 inc)
{
  struct rgen * const gi = (typeof(gi))calloc(1, sizeof(*gi));
  gi->unit_u64 = max > UINT32_MAX ? true : false;
  gi->gen.skipinc.counter_unsafe = 0;
  gi->gen.skipinc.base = min;
  gi->gen.skipinc.modulus = max - min + 1;
  gi->gen.skipinc.inc = inc;

  gi->type = GEN_SKIPINC_UNSAFE;
  gi->next_wait = gen_skipinc_unsafe;
  gi->next_nowait = gen_skipinc_unsafe;
  return gi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x220, %esi            # imm = 0x220
callq 0x62d0
movq %r14, %rcx
shrq $0x20, %rcx
setne 0x14(%rax)
movq %r15, 0x20(%rax)
subq %r15, %r14
incq %r14
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movl $0x4, 0x10(%rax)
leaq 0x12(%rip), %rcx        # 0x9f29
movq %rcx, (%rax)
movq %rcx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: rgen_new_reducer_unsafe
struct rgen *
rgen_new_reducer_unsafe(const u64 min, const u64 max)
{
  struct rgen * const gi = (typeof(gi))calloc(1, sizeof(*gi));
  gi->unit_u64 = max > UINT32_MAX ? true : false;
  gi->gen.reducer.counter_unsafe = 0;
  gi->gen.reducer.base = max;
  gi->gen.reducer.modulus = max - min + 1;

  gi->type = GEN_REDUCER_UNSAFE;
  gi->next_wait = gen_reducer_unsafe;
  gi->next_nowait = gen_reducer_unsafe;
  return gi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x220, %esi            # imm = 0x220
callq 0x62d0
movq %rbx, %rcx
shrq $0x20, %rcx
setne 0x14(%rax)
movq %rbx, 0x20(%rax)
subq %r14, %rbx
incq %rbx
movq %rbx, 0x28(%rax)
movl $0x6, 0x10(%rax)
leaq 0xc(%rip), %rcx         # 0xa010
movq %rcx, (%rax)
movq %rcx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: gen_zipfian
static u64
gen_zipfian(struct rgen * const gi)
{
  // simplified: no increamental update
  const struct rgen_zipfian * const gz = &(gi->gen.zipfian);
  const double u = random_double();
  const double uz = u * gz->zetan;
  if (uz < 1.0) {
    return gz->base;
  } else if (uz < gz->quick1) {
    return gz->base1;
  }
  //const double x = gz->nr_items_d * pow(gz->eta * (u - 1.0) + 1.0, gz->alpha);
  const double x = gz->nr_items_d * pow((gz->eta * u) + gz->quick2, gz->alpha);
  const u64 ret = gz->base + (u64)x;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %fs:-0x8, %rax
testq %rax, %rax
jne 0xa299
leaq -0x28(%rbp), %r14
movl $0x4, %edi
movq %r14, %rsi
callq 0x6110
imulq $0x3b9aca00, (%r14), %rax # imm = 0x3B9ACA00
addq 0x8(%r14), %rax
movq %rax, %rcx
shrq $0xc, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shlq $0x19, %rax
xorq %rcx, %rax
movq %rax, %rcx
shrq $0x1b, %rcx
xorq %rax, %rcx
movabsq $0x2545f4914f6cdd1d, %rax # imm = 0x2545F4914F6CDD1D
imulq %rcx, %rax
vcvtusi2sd %rax, %xmm0, %xmm0
vmulsd 0x9dad(%rip), %xmm0, %xmm0 # 0x14080
movq %rax, %fs:-0x8
vmulsd 0x40(%rbx), %xmm0, %xmm1
vmovsd 0x9d8f(%rip), %xmm2     # 0x14078
vucomisd %xmm1, %xmm2
jbe 0xa2f5
movq 0x20(%rbx), %rax
jmp 0xa334
vmovsd 0x30(%rbx), %xmm2
vucomisd %xmm1, %xmm2
jbe 0xa306
movq 0x28(%rbx), %rax
jmp 0xa334
vmovsd 0x58(%rbx), %xmm1
vfmadd213sd 0x50(%rbx), %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + mem
vmovsd 0x38(%rbx), %xmm1
vmovsd %xmm1, -0x18(%rbp)
vmovsd 0x48(%rbx), %xmm1
callq 0x6130
vmulsd -0x18(%rbp), %xmm0, %xmm0
vcvttsd2usi %xmm0, %rax
addq 0x20(%rbx), %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: rgen_new_xzipfian
struct rgen *
rgen_new_xzipfian(const u64 min, const u64 max)
{
  struct rgen * gi = rgen_new_zipfian(min, max);
  gi->unit_u64 = max > UINT32_MAX ? true : false;
  gi->type = GEN_XZIPFIAN;
  gi->next_wait = gen_xzipfian;
  gi->next_nowait = gen_xzipfian;
  return gi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xa032
shrq $0x20, %rbx
setne 0x14(%rax)
movl $0x9, 0x10(%rax)
leaq 0xe(%rip), %rcx         # 0xa36f
movq %rcx, (%rax)
movq %rcx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: rgen_new_unizipf
struct rgen *
rgen_new_unizipf(const u64 min, const u64 max, const u64 ufactor)
{
  const u64 nr = max - min + 1;
  if (ufactor == 1lu) { // covers both special gens
    return rgen_new_zipfian(min, max);
  } else if ((ufactor == 0) || ((nr / ufactor) <= 1lu)) {
    return rgen_new_uniform(min, max);
  }
  const u64 znr = nr / ufactor;
  struct rgen * gi = rgen_new_zipfian(0, znr - 1);
  gi->unit_u64 = max > UINT32_MAX ? true : false;
  gi->gen.unizipf.ufactor = ufactor;
  gi->gen.unizipf.min = min;
  gi->gen.unizipf.max = max;
  gi->next_wait = gen_unizipf;
  gi->next_nowait = gen_unizipf;
  return gi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r12
subq %rdi, %r12
testq %rdx, %rdx
je 0xa44f
movq %rdx, %r15
cmpq $0x1, %rdx
jne 0xa43f
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa032
leaq 0x1(%r12), %rax
xorl %edx, %edx
divq %r15
cmpq $0x1, %rax
ja 0xa48c
movl $0x1, %edi
movl $0x220, %esi            # imm = 0x220
callq 0x62d0
movq %rbx, %rcx
shrq $0x20, %rcx
setne 0x14(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
vcvtusi2sd %r12, %xmm0, %xmm0
vmovsd %xmm0, 0x28(%rax)
movl $0xb, 0x10(%rax)
leaq 0x143(%rip), %rcx       # 0xa5cd
jmp 0xa4bd
decq %rax
xorl %edi, %edi
movq %rax, %rsi
callq 0xa032
movq %rbx, %rcx
shrq $0x20, %rcx
setne 0x14(%rax)
movq %r15, 0x78(%rax)
movq %r14, 0x80(%rax)
movq %rbx, 0x88(%rax)
leaq 0x67(%rip), %rcx        # 0xa524
movq %rcx, (%rax)
movq %rcx, 0x8(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq