LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: rcache_clean
void
rcache_clean(struct rcache * const cache)
{
  for (u64 i = 0; i < KVMAP_HLOCK_NR; i++) {
    spinlock_lock(&(cache->hlocks[i]));
  }
  for (u64 i = 0; i < cache->nr_slots; i++) {
    struct __icache_slot * const slot = &(cache->table[i]);
    memset(slot, 0, sizeof(*slot));
  }
  for (u64 i = 0; i < KVMAP_HLOCK_NR; i++) {
    spinlock_unlock(&(cache->hlocks[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 0x12902
addq $0x40, %r14
cmpq $0x10000, %r14          # imm = 0x10000
jne 0x12892
cmpq $0x0, 0x10038(%rbx)
je 0x128e1
xorl %eax, %eax
vxorps %xmm0, %xmm0, %xmm0
xorl %ecx, %ecx
movq 0x10048(%rbx), %rdx
vmovups %ymm0, 0x20(%rdx,%rax)
vmovups %ymm0, (%rdx,%rax)
incq %rcx
addq $0x40, %rax
cmpq 0x10038(%rbx), %rcx
jb 0x128bf
xorl %r14d, %r14d
leaq (%rbx,%r14), %rdi
vzeroupper
callq 0x6320
addq $0x40, %r14
cmpq $0x10000, %r14          # imm = 0x10000
jne 0x128e4
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: rcache_destroy
void
rcache_destroy(struct rcache * const cache)
{
  rcache_clean(cache);
  pages_unmap(cache->table, cache->slots_alloc_size);
  pages_unmap(cache->hists, cache->hists_alloc_size);
  free(cache);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x12885
movq 0x10040(%rbx), %rsi
movq 0x10048(%rbx), %rdi
callq 0x6410
movq 0x10058(%rbx), %rsi
movq 0x10060(%rbx), %rdi
callq 0x6410
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6060
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: maptest_passes
int
maptest_passes(int argc, char ** argv, char ** const pref0, struct pass_info * const pi)
{
  char * pref[64];
  int np = 0;
  while (pref0[np]) {
    pref[np] = pref0[np];
    np++;
  }
  const int n1 = np;

  const int argc0 = argc;
  do {
    int pi1 = n1;
    struct rgen * gen = NULL;
    if ((argc < 1) || (strcmp(argv[0], "rgen") != 0)) {
      break;
    }
    const int n2 = rgen_helper(argc, argv, &gen);
    if (n2 < 0) {
      return n2;
    }
    for (int i = 0; i < n2; i++) {
      pref[pi1++] = argv[i];
    }
    pref[pi1] = NULL;
    argc -= n2;
    argv += n2;

    while ((argc > 0) && (strcmp(argv[0], "pass") == 0)) {
      debug_perf_switch();
      pi->gen0 = gen;
      const int n3 = maptest_pass(argc, argv, pref, pi);
      if (n3 < 0) {
        return n3;
      }
      argc -= n3;
      argv += n3;
    }

    rgen_destroy(gen);
  } while (argc > 0);
  return argc0 - argc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rcx, %r14
movq %rsi, %r15
movl %edi, %r13d
movq (%rdx), %rax
testq %rax, %rax
je 0x1304c
xorl %ecx, %ecx
movq %rax, -0x240(%rbp,%rcx,8)
movq 0x8(%rdx,%rcx,8), %rax
incq %rcx
testq %rax, %rax
jne 0x1302f
movl %ecx, %eax
movq %rax, -0x38(%rbp)
jmp 0x13054
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl %r13d, %r12d
testl %r13d, %r13d
jle 0x13183
movq (%r15), %rdi
leaq 0x135e(%rip), %rsi      # 0x143d0
callq 0x62f0
movl %r13d, %r12d
testl %eax, %eax
jne 0x13183
movq -0x38(%rbp), %rax
leaq -0x240(,%rax,8), %rbx
addq %rbp, %rbx
leaq -0x40(%rbp), %rdx
movl %r13d, %r12d
movl %r13d, -0x2c(%rbp)
movl %r12d, %edi
movq %r15, %rsi
callq 0xa7e6
testl %eax, %eax
js 0x1316f
je 0x130ca
movl %eax, %ecx
xorl %edx, %edx
movq (%r15,%rdx,8), %rsi
movq %rsi, (%rbx,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x130b5
addl -0x38(%rbp), %edx
jmp 0x130d0
xorl %ecx, %ecx
movq -0x38(%rbp), %rdx
movq $0x0, -0x240(%rbp,%rdx,8)
subl %eax, %r12d
leaq (%r15,%rcx,8), %r15
movq -0x40(%rbp), %r13
testl %r12d, %r12d
jle 0x13177
movq (%r15), %rdi
leaq 0x14ce(%rip), %rsi      # 0x145c8
callq 0x62f0
testl %eax, %eax
jne 0x1313e
movl 0x723f(%rip), %edi      # 0x1a348
testl %edi, %edi
jle 0x13117
movl $0xc, %esi
callq 0x6350
movq %r13, (%r14)
movl %r12d, %edi
movq %r15, %rsi
leaq -0x240(%rbp), %rdx
movq %r14, %rcx
callq 0x1294b
subl %eax, %r12d
movl %eax, %ecx
leaq (%r15,%rcx,8), %r15
testl %eax, %eax
jns 0x130e7
jmp 0x1316f
movq %r13, %rdi
callq 0xa769
movq $0x0, -0x40(%rbp)
movq (%r15), %rdi
leaq 0x1278(%rip), %rsi      # 0x143d0
callq 0x62f0
testl %eax, %eax
movl -0x2c(%rbp), %r13d
leaq -0x40(%rbp), %rdx
je 0x1309c
jmp 0x13183
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x13186
movq %r13, %rdi
callq 0xa769
movl -0x2c(%rbp), %r13d
subl %r12d, %r13d
movl %r13d, %eax
addq $0x218, %rsp            # imm = 0x218
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: zeta_range_worker
static void *
zeta_range_worker(void * const ptr)
{
  struct zeta_range_info * const zi = (typeof(zi))ptr;
  const u64 seq = atomic_fetch_add(&(zi->seq), 1);
  const u64 start = zi->start;
  const double theta = zi->theta;
  const u64 count = zi->count;
  const u64 nth = zi->nth;
  double local_sum = 0.0;
  for (u64 i = seq; i < count; i += nth) {
    local_sum += (1.0 / pow((double)(start + i + 1lu), theta));
  }
  spinlock_lock(&(zi->lock));
  zi->sum += local_sum;
  spinlock_unlock(&(zi->lock));
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, %r14d
lock
xaddq %r14, (%rdi)
movq 0x18(%rdi), %r15
vxorpd %xmm0, %xmm0, %xmm0
cmpq %r15, %r14
jae 0x13246
vmovsd 0x20(%rbx), %xmm0
vmovsd %xmm0, -0x38(%rbp)
movq 0x8(%rbx), %r12
movq 0x10(%rbx), %r13
incq %r13
vxorpd %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x30(%rbp)
leaq (%r14,%r13), %rax
vcvtusi2sd %rax, %xmm2, %xmm0
vmovsd -0x38(%rbp), %xmm1
callq 0x6130
vmovsd 0xe51(%rip), %xmm1      # 0x14078
vdivsd %xmm0, %xmm1, %xmm0
vmovsd -0x30(%rbp), %xmm1
vaddsd %xmm0, %xmm1, %xmm1
vmovsd %xmm1, -0x30(%rbp)
vmovsd -0x30(%rbp), %xmm0
addq %r12, %r14
cmpq %r15, %r14
jb 0x13206
vmovsd %xmm0, -0x30(%rbp)
leaq 0x30(%rbx), %r14
movq %r14, %rdi
callq 0x6050
cmpl $0x23, %eax
je 0x13284
vmovsd -0x30(%rbp), %xmm0
vaddsd 0x28(%rbx), %xmm0, %xmm0
vmovsd %xmm0, 0x28(%rbx)
movq %r14, %rdi
callq 0x6320
xorl %eax, %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: cuckoo_expand_thread
static void *
cuckoo_expand_thread(void * const ptr)
{
  struct cuckoo * const map = (typeof(map))ptr;
  debug_assert(map->bm);
  struct __cuckoo_level * const level0 = map->levels[0].table ? &(map->levels[0]) : &(map->levels[1]);
  struct __cuckoo_level * const level1 = map->levels[0].table ? &(map->levels[1]) : &(map->levels[0]);
  debug_assert(level0->table);
  debug_assert(level1->table == NULL);
  const u64 power1 = level0->power + 1;
  level1->power = power1;
  level1->table = pages_alloc_best(KVMAP_SIZE_OF_LEVEL(power1), true, &(level1->alloc_size));

  struct cuckoo_expand_worker_info info = {
    .map = map,
    .uniq = 0,
    .level0 = level0,
    .level1 = level1,
    .bm_updater = bitmap_count(map->bm) ? bitmap_set0 : bitmap_set1,
  };
  const double dt = thread_fork_join(0, cuckoo_expand_worker, &info);
  (void)dt;
  //fprintf(stderr, "%s workers time %.2lf\n", __func__, dt);
  debug_assert(atomic_load(&info.uniq) > KVMAP_HLOCK_NR);
  pages_unmap(level0->table, level0->alloc_size);
  level0->table = NULL;
  mutexlock_unlock(&(map->expand_lock));
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x100d8(%rdi)
je 0x13696
movl $0x10118, %eax          # imm = 0x10118
leaq (%rbx,%rax), %rcx
movl $0x10130, %r14d         # imm = 0x10130
leaq (%rbx,%r14), %r13
cmpq $0x0, 0x10118(%rbx)
movl $0x10118, %r15d         # imm = 0x10118
cmoveq %r14, %r15
movq %rcx, %r12
cmoveq %r13, %r12
cmoveq %rax, %r14
cmoveq %rcx, %r13
cmpq $0x0, (%rbx,%r15)
je 0x136a0
cmpq $0x0, (%r13)
jne 0x136aa
movq 0x10(%r12), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%r13)
addb $-0x5, %al
movl $0x1000, %ecx           # imm = 0x1000
shlxq %rax, %rcx, %rdi
leaq 0x8(%r13), %rdx
movl $0x1, %esi
callq 0x82a0
movq %rax, (%rbx,%r14)
leaq -0x50(%rbp), %r14
movq %rbx, (%r14)
movq $0x0, 0x8(%r14)
movq %r12, 0x10(%r14)
movq %r13, 0x18(%r14)
movq 0x100d8(%rbx), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
leaq -0xbd9b(%rip), %rax     # 0x7890
leaq -0xbd6e(%rip), %rcx     # 0x78c4
cmoveq %rax, %rcx
movq %rcx, 0x20(%r14)
leaq 0x81(%rip), %rsi        # 0x136c2
xorl %edi, %edi
movq %r14, %rdx
callq 0x806e
movq 0x8(%r14), %rax
cmpq $0x400, %rax            # imm = 0x400
jbe 0x136b4
movq (%rbx,%r15), %rdi
movq 0x8(%r12), %rsi
callq 0x6410
movq $0x0, (%rbx,%r15)
addq $0x10050, %rbx          # imm = 0x10050
movq %rbx, %rdi
callq 0x6390
cmpl $0xb, %eax
je 0x13674
testl %eax, %eax
jne 0x136bb
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x66ef
jmp 0x1358a
callq 0x66ef
jmp 0x135c9
callq 0x66ef
jmp 0x135d4
callq 0x66ef
jmp 0x13657
xorl %edi, %edi
callq 0x6530
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: chainmap_expand_thread
static void *
chainmap_expand_thread(void * const ptr)
{
  struct chainmap * const map = (typeof(map))ptr;
  struct chainmap_expand_worker_info info;
  info.map = map;
  info.new_power = map->power + 1;
  const u64 table_size = sizeof(map->table[0]) * (UINT64_C(1) << info.new_power);
  info.new_table = (typeof(info.new_table))pages_alloc_best(table_size, true, &(info.new_alloc_size));
  debug_assert(info.new_table);
  atomic_store(&(info.uniq), 0);
  const double dt = thread_fork_join(0, chainmap_expand_worker, &info);
  pages_unmap(map->table, map->alloc_size);
  map->table = info.new_table;
  map->alloc_size = info.new_alloc_size;
  map->power = info.new_power;
  map->trigger = UINT64_C(2) << map->power;
  atomic_thread_fence(memory_order_seq_cst);

  for (u64 i = 0; i < KVMAP_HLOCK_NR; i++) {
    spinlock_unlock(&(map->hlocks[i]));
  }
  mutexlock_unlock(&(map->expand_lock));
  fprintf(stderr, "%s workers time %.2lf\n", __func__, dt);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %rdi, -0x18(%r14)
movq 0xd0(%rdi), %rax
incq %rax
movq %rax, -0x10(%r14)
movl $0x8, %ecx
shlxq %rax, %rcx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x82a0
movq %rax, -0x8(%r14)
testq %rax, %rax
jne 0x13925
callq 0x66ef
xorl %r15d, %r15d
leaq -0x48(%rbp), %r14
xorl %eax, %eax
xchgq %rax, 0x20(%r14)
leaq 0xc4(%rip), %rsi        # 0x139fd
xorl %edi, %edi
movq %r14, %rdx
callq 0x806e
vmovsd %xmm0, -0x20(%rbp)
movq 0xe8(%rbx), %rdi
movq 0xf0(%rbx), %rsi
callq 0x6410
movq 0x10(%r14), %rax
movq %rax, 0xe8(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0xf0(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0xd0(%rbx)
movl $0x2, %ecx
shlxq %rax, %rcx, %rax
movq %rax, 0xd8(%rbx)
mfence
leaq 0x138(%rbx), %r14
leaq (%r14,%r15), %rdi
callq 0x6320
addq $0x40, %r15
cmpq $0x10000, %r15          # imm = 0x10000
jne 0x13997
addq $0xf8, %rbx
movq %rbx, %rdi
callq 0x6390
cmpl $0xb, %eax
je 0x139b4
testl %eax, %eax
jne 0x139f6
movq 0x662c(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0xe11(%rip), %rsi       # 0x147e7
leaq 0xe21(%rip), %rdx       # 0x147fe
vmovsd -0x20(%rbp), %xmm0
movb $0x1, %al
callq 0x6300
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
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: chainmap_expand_worker
static void *
chainmap_expand_worker(void * const ptr)
{
  struct chainmap_expand_worker_info * const info = (typeof(info))ptr;
  struct chainmap * const map = info->map;
  debug_assert(map->power >= KVMAP_HLOCK_POWER);
  const u64 hi_max = UINT64_C(1) << (map->power - KVMAP_HLOCK_POWER);
  do {
    const u64 lidx = atomic_fetch_add(&(info->uniq), 1);
    if (lidx >= KVMAP_HLOCK_NR) break;
    spinlock_lock(&(map->hlocks[lidx]));
    for (u64 h = 0; h < hi_max; h++) {
      const u64 hidx = (h << KVMAP_HLOCK_POWER) | lidx;
      struct chainnode * iter = info->map->table[hidx];
      while (iter) {
        struct chainnode * const next = iter->next;
        struct kv * const curr = __u64_to_ptr(iter->e.ptr);
        const u64 h2 = (curr->hash >> KVMAP_BASE_LEVEL) & ((UINT64_C(1) << info->new_power) - UINT64_C(1));
        iter->next = info->new_table[h2];
        info->new_table[h2] = iter;
        iter = next;
      }
    }
  } while (true);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0xd0(%r14), %r15
cmpq $0x9, %r15
jbe 0x13af4
movl $0x1, %r12d
lock
xaddq %r12, 0x20(%rbx)
cmpq $0x3ff, %r12            # imm = 0x3FF
ja 0x13ae3
addq $-0xa, %r15
addq $0x138, %r14            # imm = 0x138
movq $-0x1, %r13
movq %r12, %rdi
shlq $0x6, %rdi
addq %r14, %rdi
callq 0x6050
cmpl $0x23, %eax
je 0x13b05
xorl %eax, %eax
movq (%rbx), %rcx
movq 0xe8(%rcx), %rcx
movq %rax, %rdx
shlq $0xd, %rdx
leaq (%rdx,%r12,8), %rdx
movq (%rcx,%rdx), %rcx
testq %rcx, %rcx
je 0x13abd
movb 0x8(%rbx), %dl
shlxq %rdx, %r13, %rdx
notq %rdx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdi
shrq $0x10, %rsi
movq (%rsi), %rsi
shrq $0x6, %rsi
andq %rdx, %rsi
movq 0x10(%rbx), %r8
movq (%r8,%rsi,8), %r9
movq %r9, 0x8(%rcx)
movq %rcx, (%r8,%rsi,8)
movq %rdi, %rcx
testq %rdi, %rdi
jne 0x13a90
incq %rax
shrxq %r15, %rax, %rcx
testq %rcx, %rcx
je 0x13a67
movl $0x1, %r12d
lock
xaddq %r12, 0x20(%rbx)
cmpq $0x3ff, %r12            # imm = 0x3FF
jbe 0x13a4d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x66ef
movq 0xd0(%r14), %r15
jmp 0x13a22
xorl %edi, %edi
callq 0x6530
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/lib1.c
// Function: bptree_raw_insert_intm
static void
bptree_raw_insert_intm(struct bpnode * const node, const u64 idx, const struct kv * const key, struct bpnode * const sub)
{
  debug_assert(idx <= node->nr);
  memmove(&(node->iarray[idx + 1]), &(node->iarray[idx]), sizeof(node->iarray[0]) * (node->nr - idx));
  node->iarray[idx].key = key;
  node->iarray[idx].sub = sub;
  node->nr++;
  // link
  if (node->nr > 1) {
    if (idx > 0) {
      struct bpnode * const left = node->iarray[idx - 1].sub;
      if (left->next) {
        sub->next = left->next;
        left->next->prev = sub;
      }
      sub->prev = left;
      left->next = sub;
    } else {
      struct bpnode * const right = node->iarray[idx + 1].sub;
      if (right->prev) {
        sub->prev = right->prev;
        right->prev->next = sub;
      }
      sub->next = right;
      right->prev = sub;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, -0x38(%rbp)
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %rdx
cmpq %rsi, %rdx
jb 0x13be1
movq %r12, %r15
shlq $0x4, %r15
leaq (%r14,%r15), %rdi
addq $0x30, %rdi
leaq (%r14,%r15), %rbx
addq $0x20, %rbx
subq %r12, %rdx
shlq $0x4, %rdx
movq %rdi, -0x30(%rbp)
movq %rbx, %rsi
callq 0x6450
movq -0x38(%rbp), %rax
movq %rax, (%rbx)
movq %r13, 0x8(%rbx)
movq 0x8(%r14), %rax
incq %rax
movq %rax, 0x8(%r14)
cmpq $0x2, %rax
jb 0x13bd2
testq %r12, %r12
je 0x13b9f
addq $0x20, %r14
movq -0x8(%r15,%r14), %rax
leaq 0x10(%rax), %rcx
movq 0x10(%rax), %rsi
movl $0x10, %edi
movl $0x18, %edx
jmp 0x13bb9
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0x18(%rax), %rcx
movq 0x18(%rax), %rsi
movl $0x18, %edi
movl $0x10, %edx
testq %rsi, %rsi
je 0x13bca
movq %rsi, (%r13,%rdi)
movq (%rcx), %rsi
movq %r13, (%rsi,%rdx)
movq %rax, (%r13,%rdx)
movq %r13, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x66ef
movq 0x8(%r14), %rdx
jmp 0x13b37
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/gram.c
// Function: yy_stack_print
static void
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x3fb9f(%rip), %r12     # 0x43ff0
movq (%r12), %rcx
leaq 0x30f8e(%rip), %rdi     # 0x353ea
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x4330
cmpq %rbx, %r14
ja 0x448e
leaq 0x2c67d(%rip), %r15     # 0x30af0
movswl (%r14), %edx
movq (%r12), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4240
addq $0x2, %r14
cmpq %rbx, %r14
jbe 0x4473
movq (%r12), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x41f0
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/blob.c
// Function: mkblobi
Blob *
mkblobi(Blobtype type, uint64_t ival)
{
	Blob *b;

	b = zalloc(sizeof(Blob));
	b->type = type;
	b->ival = ival;
	return b;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x38, %edi
callq 0x2ce48
movl %ebp, (%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/blob.c
// Function: mkblobbytes
Blob *
mkblobbytes(char *buf, size_t len)
{
	Blob *b;

	b = zalloc(sizeof(Blob));
	b->type = Btbytes;
	b->bytes.buf = buf;
	b->bytes.len = len;
	return b;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x38, %edi
callq 0x2ce48
movl $0x6, (%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/blob.c
// Function: mkblobseq
Blob *
mkblobseq(Blob **sub, size_t nsub)
{
	Blob *b;

	b = zalloc(sizeof(Blob));
	b->type = Btseq;
	b->seq.sub = sub;
	b->seq.nsub = nsub;
	return b;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x38, %edi
callq 0x2ce48
movl $0x7, (%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/blob.c
// Function: mkblobref
Blob *
mkblobref(char *lbl, size_t off, int isextern)
{
	Blob *b;

	b = zalloc(sizeof(Blob));
	b->type = Btref;
	b->ref.str = strdup(lbl);
	b->ref.isextern = isextern;
	b->ref.off = off;
	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x38, %edi
callq 0x2ce48
movq %rax, %r12
movl $0x5, (%rax)
movq %r15, %rdi
callq 0x4340
movq %rax, 0x20(%r12)
movb %bl, 0x28(%r12)
movq %r14, 0x30(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/blob.c
// Function: blobfree
void
blobfree(Blob *b)
{
	size_t i;

	if (!b)
		return;
	switch (b->type) {
	case Btref:
		free(b->lbl);
		break;
	case Btseq:
		for (i = 0; i < b->seq.nsub; i++)

			blobfree(b->seq.sub[i]);
		break;
	default:
		break;
	}
	free(b);
}

// Assembly:
testq %rdi, %rdi
je 0x4a2c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x5, %eax
je 0x4a2d
cmpl $0x7, %eax
jne 0x4a36
cmpq $0x0, 0x20(%rbx)
je 0x4a36
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x49f2
incq %r14
cmpq 0x20(%rbx), %r14
jb 0x4a14
jmp 0x4a36
retq
movq 0x10(%rbx), %rdi
callq 0x4040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4040
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/blob.c
// Function: litblob
Blob *
litblob(Htab *globls, Htab *strtab, Node *n)
{
	Blob *b;

	b = mkblobseq(NULL, 0);
	blobrec(b, globls, strtab, n);
	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x38, %edi
callq 0x2ce48
movq %rax, %r12
movl $0x7, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x4aa0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/gen.c
// Function: fillglobls
void
fillglobls(Stab *st, Htab *globls)
{
	size_t i, j, nk, nns;
	void **k, **ns;
	Stab *stab;
	Node *s;

	k = htkeys(st->dcl, &nk);
	for (i = 0; i < nk; i++) {
		s = htget(st->dcl, k[i]);
		if (isconstfn(s))
			s->decl.type = codetype(s->decl.type);
		htput(globls, s, asmname(s));
	}
	free(k);

	ns = htkeys(file.ns, &nns);
	for (j = 0; j < nns; j++) {
		stab = htget(file.ns, ns[j]);
		k = htkeys(stab->dcl, &nk);
		for (i = 0; i < nk; i++) {
			s = htget(stab->dcl, k[i]);
			htput(globls, s, asmname(s));
		}
		free(k);
	}
	free(ns);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0x2da36
movq %rax, %r15
cmpq $0x0, (%r12)
je 0x547e
xorl %r13d, %r13d
movq 0x18(%r14), %rdi
movq (%r15,%r13,8), %rsi
callq 0x2d8fa
movq %rax, %r12
movq %rax, %rdi
callq 0x28999
testl %eax, %eax
je 0x545f
movq 0x28(%r12), %rdi
callq 0x5543
movq %rax, 0x28(%r12)
movq %r12, %rdi
callq 0x5584
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2d71e
incq %r13
cmpq (%rsp), %r13
jb 0x5434
movq %r15, %rdi
callq 0x4040
leaq 0x5bdeb(%rip), %rax     # 0x61278
movq 0xa0(%rax), %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rsi
callq 0x2da36
movq %rax, 0x8(%rsp)
cmpq $0x0, (%r15)
je 0x552a
xorl %r15d, %r15d
leaq 0x5bdc2(%rip), %rax     # 0x61278
movq 0xa0(%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax,%r15,8), %rsi
callq 0x2d8fa
movq %rax, %r12
movq 0x18(%rax), %rdi
movq %rsp, %rsi
callq 0x2da36
movq %rax, %r13
cmpq $0x0, (%rsp)
je 0x5518
xorl %r14d, %r14d
movq 0x18(%r12), %rdi
movq (%r13,%r14,8), %rsi
callq 0x2d8fa
movq %rax, %rbp
movq %rax, %rdi
callq 0x5584
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x2d71e
incq %r14
cmpq (%rsp), %r14
jb 0x54e7
movq %r13, %rdi
callq 0x4040
incq %r15
cmpq 0x10(%rsp), %r15
jb 0x54af
movq 0x8(%rsp), %rdi
callq 0x4040
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/gen.c
// Function: codetype
Type *
codetype(Type *ft)
{
	ft = tybase(ft);
	if (ft->type == Tycode)
		return ft;
	assert(ft->type == Tyfunc);
	ft = tydup(ft);
	ft->type = Tycode;
	return ft;
}

// Assembly:
pushq %rax
callq 0x227ac
movl (%rax), %ecx
cmpl $0x13, %ecx
je 0x5574
cmpl $0x1e, %ecx
je 0x5582
leaq 0x29ccf(%rip), %rdi     # 0x2f22b
leaq 0x29cdb(%rip), %rsi     # 0x2f23e
leaq 0x29cda(%rip), %rcx     # 0x2f244
movl $0x51, %edx
callq 0x4180
movq %rax, %rdi
callq 0x22953
movl $0x1e, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/gen.c
// Function: asmname
char *
asmname(Node *dcl)
{
	char buf[1024];
	char *vis, *pf, *ns, *name, *sep;
	Node *n;

	n = dcl->decl.name;
	pf = Symprefix;
	ns = n->name.ns;
	name = n->name.name;
	vis = "";
	sep = "";
	if (asmsyntax == Plan9)
		if (islocal(dcl))
			vis = "<>";
	if (!ns || !ns[0])
		ns = "";
	else
		sep = "$";
	if (name[0] == '.')
		pf = "";

	bprintf(buf, sizeof buf, "%s%s%s%s%s", pf, ns, sep, name, vis);
	return strdup(buf);
}

// Assembly:
movq 0x20(%rdi), %rcx
movq 0x18(%rcx), %rax
leaq 0x5bc35(%rip), %rdx     # 0x611c8
leaq 0x2c8b0(%rip), %r8      # 0x31e4a
cmpl $0x2, (%rdx)
movq %r8, %r10
jne 0x55b7
cmpb $0x0, 0x70(%rdi)
jne 0x55b4
cmpb $0x0, 0x77(%rdi)
jne 0x55b4
cmpb $0x0, 0x74(%rdi)
je 0x5620
movq %r8, %r10
movq 0x20(%rcx), %r11
movq %r8, %r9
testq %rax, %rax
je 0x55df
cmpb $0x0, (%rax)
leaq 0x2c87d(%rip), %rcx     # 0x31e4a
cmoveq %rcx, %rax
leaq 0x29c9d(%rip), %r9      # 0x2f275
cmoveq %rcx, %r9
movq %rax, %r8
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
leaq 0x29c89(%rip), %rdx     # 0x2f277
leaq 0x2c855(%rip), %rcx     # 0x31e4a
movq %rsp, %rbx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x2dfae
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x4340
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
leaq 0x2b0d3(%rip), %r10     # 0x306fa
jmp 0x55b7
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/gen.c
// Function: initconsts
void
initconsts(Htab *globls)
{
	Type *ty;
	Node *name;
	Node *dcl;

	tyintptr = mktype(Zloc, Tyuint64);
	tyword = mktype(Zloc, Tyuint);
	tyvoid = mktype(Zloc, Tyvoid);

	ty = mktyfunc(Zloc, NULL, 0, mktype(Zloc, Tyvoid));
	ty->type = Tycode;
	name = mknsname(Zloc, "_rt", "abort_oob");
	dcl = mkdecl(Zloc, name, ty);
	dcl->decl.isconst = 1;
	dcl->decl.isextern = 1;
	htput(globls, dcl, asmname(dcl));

	abortoob = mkexpr(Zloc, Ovar, name, NULL);
	abortoob->expr.type = ty;
	abortoob->expr.did = dcl->decl.did;
	abortoob->expr.isconst = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xe, %esi
callq 0x2289d
leaq 0x5bcde(%rip), %rcx     # 0x61328
movq %rax, (%rcx)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xc, %esi
callq 0x2289d
leaq 0x5bccd(%rip), %rcx     # 0x61330
movq %rax, (%rcx)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x1, %esi
callq 0x2289d
leaq 0x5bcbc(%rip), %rcx     # 0x61338
movq %rax, (%rcx)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x1, %esi
callq 0x2289d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
callq 0x22d97
movq %rax, %r14
movl $0x1e, (%rax)
leaq 0x29b6e(%rip), %rsi     # 0x2f21d
leaq 0x29b6b(%rip), %rdx     # 0x2f221
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1dfda
movq %rax, %r15
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %rax, %rsi
movq %r14, %rdx
callq 0x1e04f
movq %rax, %r12
movb $0x1, %al
movb %al, 0x72(%r12)
movb %al, 0x74(%r12)
movq %r12, %rdi
callq 0x5584
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2d71e
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x33, %esi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
leaq 0x5bc2b(%rip), %rcx     # 0x61340
movq %rax, (%rcx)
movq %r14, 0x20(%rax)
movq 0x18(%r12), %rcx
movq %rcx, 0x38(%rax)
movl $0x1, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/gen.c
// Function: closuretype
Type *
closuretype(Type *ft)
{
	ft = tybase(ft);
	if (ft->type == Tyfunc)
		return ft;
	assert(ft->type == Tycode);
	ft = tydup(ft);
	ft->type = Tyfunc;
	return ft;
}

// Assembly:
pushq %rax
callq 0x227ac
movl (%rax), %ecx
cmpl $0x13, %ecx
je 0x5758
cmpl $0x1e, %ecx
jne 0x575a
movq %rax, %rdi
callq 0x22953
movl $0x13, (%rax)
popq %rcx
retq
leaq 0x3342c(%rip), %rdi     # 0x38b8d
leaq 0x29ad6(%rip), %rsi     # 0x2f23e
leaq 0x29aec(%rip), %rcx     # 0x2f25b
movl $0x5d, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/gen.c
// Function: tydescid
char *
tydescid(char *buf, size_t bufsz, Type *ty)
{
	char *sep, *ns;
	char *p, *end;
	size_t i;

	sep = "";
	ns = "";
	p = buf;
	end = buf + bufsz;
	ty = tydedup(ty);
	if (ty->type == Tyname) {
		if (ty->name->name.ns) {
			ns = ty->name->name.ns;
			sep = "$";
		}
		if (ty->vis != Visintern || ty->isimport)
			p += bprintf(p, end - p, "_tydesc$%s%s%s", ns, sep, ty->name->name.name, ty->tid);
		else
			p += bprintf(p, end - p, "_tydesc$%s%s%s$%d", ns, sep, ty->name->name.name, ty->tid);
		for (i = 0; i < ty->narg; i++)
			p += tyidfmt(p, end - p, ty->arg[i]);
	} else {
		if (file.globls->name) {
			ns = file.globls->name;
			sep = "$";
		}
		bprintf(buf, bufsz, "_tydesc%s%s$%d",sep, ns, ty->tid);
	}
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x22851
movq %rax, %r15
cmpl $0x1c, (%rax)
jne 0x57f6
movq 0x88(%r15), %rax
movq 0x18(%rax), %rcx
testq %rcx, %rcx
leaq 0x2c673(%rip), %rdx     # 0x31e4a
leaq 0x29a97(%rip), %r8      # 0x2f275
cmoveq %rdx, %r8
cmoveq %rdx, %rcx
cmpl $0x0, 0x10(%r15)
je 0x583b
leaq 0x29a8e(%rip), %rdx     # 0x2f282
jmp 0x5855
leaq 0x5ba7b(%rip), %rax     # 0x61278
movq 0x90(%rax), %rax
movq 0x8(%rax), %r8
testq %r8, %r8
leaq 0x2c638(%rip), %rax     # 0x31e4a
leaq 0x29a5c(%rip), %rcx     # 0x2f275
cmoveq %rax, %rcx
cmoveq %rax, %r8
movl 0x4(%r15), %r9d
leaq 0x29a77(%rip), %rdx     # 0x2f2a3
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2dfae
jmp 0x58a2
cmpb $0x0, 0x94(%r15)
leaq 0x29a47(%rip), %rsi     # 0x2f291
leaq 0x29a31(%rip), %rdx     # 0x2f282
cmoveq %rsi, %rdx
movq 0x20(%rax), %r9
movl 0x4(%r15), %eax
movl %eax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2dfae
cmpq $0x0, 0x48(%r15)
je 0x58a2
movq %rax, %r12
addq %rbx, %r14
addq %rbx, %r12
xorl %r13d, %r13d
movq %r14, %rsi
subq %r12, %rsi
movq 0x40(%r15), %rax
movq (%rax,%r13,8), %rdx
movq %r12, %rdi
callq 0x2409c
addq %rax, %r12
incq %r13
cmpq 0x48(%r15), %r13
jb 0x5880
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/gen.c
// Function: gen
void
gen(char *out)
{
	FILE *fd;

	fd = fopen(out, "w");
	if (!fd)
		die("Couldn't open fd %s", out);

	switch (asmsyntax) {
	case Plan9:
		genp9(fd);
		break;
	case Gnugaself:
	case Gnugasmacho:
		gengas(fd);
		break;
	default:
		die("unknown target");  break;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2a025(%rip), %rsi     # 0x2f8e3
callq 0x42e0
testq %rax, %rax
je 0x58e8
leaq 0x5b8f9(%rip), %rcx     # 0x611c8
cmpl $0x2, (%rcx)
jae 0x58dd
movq %rax, %rdi
popq %rbx
jmp 0x6323
jne 0x58f9
movq %rax, %rdi
popq %rbx
jmp 0x6890
leaq 0x299c3(%rip), %rdi     # 0x2f2b2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x13844
leaq 0x299c6(%rip), %rdi     # 0x2f2c6
xorl %eax, %eax
callq 0x13844
nop
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/gengas.c
// Function: printmem
void
printmem(FILE *fd, Loc *l, char spec)
{
	if (l->type == Locmem) {
		if (l->mem.constdisp)
			fprintf(fd, "%ld", l->mem.constdisp);
	} else {
		if (l->mem.lbldisp)
			fprintf(fd, "%s", l->mem.lbldisp);
	}
	if (l->mem.base) {
		fprintf(fd, "(");
		locprint(fd, l->mem.base, 'r');
		if (l->mem.idx) {
			fprintf(fd, ",");
			locprint(fd, l->mem.idx, 'r');
		}
		if (l->mem.scale > 1)
			fprintf(fd, ",%d", l->mem.scale);
		if (l->mem.base)
			fprintf(fd, ")");
	} else if (l->type != Locmeml) {
		die("Only locmeml can have unspecified base reg");
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x3, (%rsi)
jne 0x5933
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x5944
leaq 0x29f06(%rip), %rsi     # 0x2f82d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4240
jmp 0x5944
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x5944
movq %rbx, %rsi
callq 0x4190
cmpq $0x0, 0x28(%r14)
je 0x59c3
movl $0x28, %edi
movq %rbx, %rsi
callq 0x41f0
movq 0x28(%r14), %rsi
movq %rbx, %rdi
movl $0x72, %edx
callq 0x59df
cmpq $0x0, 0x30(%r14)
je 0x598e
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x41f0
movq 0x30(%r14), %rsi
movq %rbx, %rdi
movl $0x72, %edx
callq 0x59df
movl 0x20(%r14), %edx
cmpl $0x2, %edx
jl 0x59a8
leaq 0x29c22(%rip), %rsi     # 0x2f5c0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4240
cmpq $0x0, 0x28(%r14)
je 0x59c9
movl $0x29, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41f0
cmpl $0x4, (%r14)
jne 0x59d1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x29bec(%rip), %rdi     # 0x2f5c4
xorl %eax, %eax
callq 0x13844
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/gengas.c
// Function: genstrings
void
genstrings(FILE *fd, Htab *strtab)
{
	void **k;
	Str *s;
	size_t i, nk;

	k = htkeys(strtab, &nk);
	for (i = 0; i < nk; i++) {
		s = k[i];
		fprintf(fd, "%s:\n", (char*)htget(strtab, k[i]));
		writebytes(fd, s->buf, s->len);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x2da36
cmpq $0x0, (%r12)
je 0x5e67
movq %rax, %r15
leaq 0x29f2e(%rip), %r12     # 0x2fd5b
xorl %ebp, %ebp
movq (%r15,%rbp,8), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2d8fa
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4240
movq (%r13), %rdx
movq 0x8(%r13), %rsi
movq %r14, %rdi
callq 0x5e76
incq %rbp
cmpq (%rsp), %rbp
jb 0x5e2f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/gengas.c
// Function: writebytes
static void
writebytes(FILE *fd, char *p, size_t sz)
{
	size_t i;

	for (i = 0; i < sz; i++) {
		if (i % 60 == 0)
			fprintf(fd, "\t.ascii \"");
		if (p[i] == '"' || p[i] == '\\')
			fprintf(fd, "\\");
		if (isprint(p[i]))
			fprintf(fd, "%c", p[i]);
		else
			fprintf(fd, "\\%03o", (uint8_t)p[i] & 0xff);
		/* line wrapping for readability */
		if (i % 60 == 59 || i == sz - 1)
			fprintf(fd, "\"\n");
	}
}

// Assembly:
testq %rdx, %rdx
je 0x5f74
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x1(%rdx), %rax
movq %rax, (%rsp)
xorl %r12d, %r12d
movq %r12, %rax
movabsq $-0x7777777777777777, %rcx # imm = 0x8888888888888889
mulq %rcx
shrq $0x5, %rdx
imulq $0x3c, %rdx, %rbp
cmpq %r12, %rbp
jne 0x5ed4
movl $0x9, %esi
movl $0x1, %edx
leaq 0x29e70(%rip), %rdi     # 0x2fd3c
movq %r15, %rcx
callq 0x4330
movzbl (%r14,%r12), %r13d
cmpl $0x5c, %r13d
je 0x5ee5
cmpl $0x22, %r13d
jne 0x5ef6
movl $0x5c, %edi
movq %r15, %rsi
callq 0x41f0
movb (%r14,%r12), %r13b
callq 0x4390
movq (%rax), %rax
movsbq %r13b, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
jne 0x5f20
movzbl %r13b, %edx
movq %r15, %rdi
leaq 0x29e2f(%rip), %rsi     # 0x2fd46
xorl %eax, %eax
callq 0x4240
jmp 0x5f2c
movsbl %r13b, %edi
movq %r15, %rsi
callq 0x41f0
addq $0x3b, %rbp
cmpq %r12, %rbp
setne %al
cmpq %r12, (%rsp)
setne %cl
testb %al, %cl
jne 0x5f5a
movl $0x2, %esi
movl $0x1, %edx
leaq 0x2a6aa(%rip), %rdi     # 0x305fc
movq %r15, %rcx
callq 0x4330
incq %r12
cmpq %r12, %rbx
jne 0x5e9e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/gengas.c
// Function: genblob
void
genblob(FILE *fd, Node *blob, Htab *globls, Htab *strtab)
{
	char *lbl;
	Blob *b;

	/* lits and such also get wrapped in decls */
	assert(blob->type == Ndecl);

	lbl = htget(globls, blob);
	if (blob->decl.vis != Visintern)
		fprintf(fd, ".globl %s\n", lbl);
	if (asmsyntax == Gnugaself)
		fprintf(fd, ".section .data.%s,\"aw\",@progbits\n", lbl);
	if (blob->decl.init) {
		fprintf(fd, ".align %zd\n", tyalign(decltype(blob)));
		fprintf(fd, "%s:\n", lbl);

		b = litblob(globls, strtab, blob->decl.init);
		writeblob(fd, b);
		blobfree(b);
	} else {
		fprintf(fd, ".comm %s,%zd\n", lbl, size(blob));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0xb, 0x8(%rsi)
jne 0x6072
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x2d8fa
movq %rax, %r13
cmpb $0x0, 0x70(%r12)
je 0x5fbb
leaq 0x296e4(%rip), %rsi     # 0x2f692
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4240
leaq 0x5b206(%rip), %rax     # 0x611c8
cmpl $0x0, (%rax)
jne 0x5fdb
leaq 0x296cf(%rip), %rsi     # 0x2f69d
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4240
cmpq $0x0, 0x30(%r12)
je 0x604a
movq %r12, %rdi
callq 0x1e31c
movq %rax, %rdi
callq 0x12677
leaq 0x296c5(%rip), %rsi     # 0x2f6bf
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4240
leaq 0x29d4d(%rip), %rsi     # 0x2fd5b
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4240
movq 0x30(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4a55
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6091
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x49f2
movq %r12, %rdi
callq 0x12664
leaq 0x29672(%rip), %rsi     # 0x2f6cb
movq %rbx, %rdi
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4240
leaq 0x295d8(%rip), %rdi     # 0x2f651
leaq 0x29591(%rip), %rsi     # 0x2f611
leaq 0x295de(%rip), %rcx     # 0x2f665
movl $0x194, %edx            # imm = 0x194
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/gengas.c
// Function: writeasm
static void
writeasm(FILE *fd, Isel *s, Func *fn)
{
	size_t i, j;

	switch (asmsyntax) {
	case Gnugaself:
		//fprintf(fd, ".section .text.%s,\"ax\",@progbits\n", fn->name);
		fprintf(fd, ".type %s, @function\n", fn->name);
		break;
	case Gnugasmacho:
		fprintf(fd, ".section __TEXT,__text,regular\n");
		break;
	default:
		die("unknown target");  break;
	}
	if (fn->isexport)
		fprintf(fd, ".globl %s\n", fn->name);
	fprintf(fd, "%s:\n", fn->name);
	for (j = 0; j < s->cfg->nbb; j++) {
		if (!s->bb[j])
			continue;
		for (i = 0; i < s->bb[j]->nlbls; i++)
			fprintf(fd, "%s:\n", s->bb[j]->lbls[i]);
		for (i = 0; i < s->bb[j]->ni; i++)
			iprintf(fd, s->bb[j]->il[i]);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5aa53(%rip), %rax     # 0x611c8
movl (%rax), %eax
cmpl $0x1, %eax
je 0x679a
testl %eax, %eax
jne 0x6880
movq (%r15), %rdx
leaq 0x2969e(%rip), %rsi     # 0x2fe2c
movq %r14, %rdi
xorl %eax, %eax
callq 0x4240
jmp 0x67b3
leaq 0x296a0(%rip), %rdi     # 0x2fe41
movl $0x1f, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x4330
cmpb $0x0, 0x58(%r15)
je 0x67ce
movq (%r15), %rdx
leaq 0x28ece(%rip), %rsi     # 0x2f692
movq %r14, %rdi
xorl %eax, %eax
callq 0x4240
movq (%r15), %rdx
leaq 0x29583(%rip), %rsi     # 0x2fd5b
movq %r14, %rdi
xorl %eax, %eax
callq 0x4240
movq 0x10(%rbx), %rax
cmpq $0x0, 0x20(%rax)
je 0x6876
movq 0x18(%rbx), %rax
leaq 0x2955f(%rip), %r15     # 0x2fd5b
xorl %r12d, %r12d
movq (%rax,%r12,8), %rcx
testq %rcx, %rcx
je 0x6869
cmpq $0x0, 0x10(%rcx)
je 0x683a
xorl %r13d, %r13d
movq 0x8(%rcx), %rax
movq (%rax,%r13,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4240
incq %r13
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rcx
cmpq 0x10(%rcx), %r13
jb 0x6812
jmp 0x683e
movq (%rax,%r12,8), %rcx
cmpq $0x0, 0x20(%rcx)
je 0x6869
xorl %r13d, %r13d
movq 0x18(%rcx), %rax
movq (%rax,%r13,8), %rsi
movq %r14, %rdi
callq 0x5c33
incq %r13
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rcx
cmpq 0x20(%rcx), %r13
jb 0x6848
incq %r12
movq 0x10(%rbx), %rcx
cmpq 0x20(%rcx), %r12
jb 0x67ff
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x28a3f(%rip), %rdi     # 0x2f2c6
xorl %eax, %eax
callq 0x13844
nop
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/genp9.c
// Function: writebytes
static size_t
writebytes(FILE *fd, char *name, size_t off, char *p, size_t sz)
{
	size_t i, len;

	assert(sz != 0);
	for (i = 0; i < sz; i++) {
		len = min(sz - i, 8);
		if (i % 8 == 0)
			fprintf(fd, "\tDATA %s+%llu(SB)/%llu,$\"", name, (uvlong)off + i, (uvlong)len);
		if (p[i] == '"' || p[i] == '\\')
			fprintf(fd, "\\");
		if (isprint(p[i]))
			fprintf(fd, "%c", p[i]);
		else
			fprintf(fd, "\\%03o", (uint8_t)p[i] & 0xff);
		/* line wrapping for readability */
		if (i % 8 == 7 || i == sz - 1)
			fprintf(fd, "\"\n");
	}

	return sz;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
testq %r8, %r8
je 0x7085
movq %rcx, %r14
movq %rdi, %r13
movq %r8, (%rsp)
movq %r8, %rbx
xorl %ebp, %ebp
movl $0x8, %esi
movq %rbx, %rdi
callq 0x2e20c
movq %rbp, %r15
andq $0x7, %r15
jne 0x6fe3
movq 0x10(%rsp), %rcx
addq %rbp, %rcx
movq %r13, %rdi
leaq 0x292f1(%rip), %rsi     # 0x302c5
movq 0x8(%rsp), %rdx
movq %rax, %r8
xorl %eax, %eax
callq 0x4240
movzbl (%r14,%rbp), %r12d
cmpl $0x5c, %r12d
je 0x6ff4
cmpl $0x22, %r12d
jne 0x7005
movl $0x5c, %edi
movq %r13, %rsi
callq 0x41f0
movb (%r14,%rbp), %r12b
callq 0x4390
movq (%rax), %rax
movsbq %r12b, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
jne 0x702f
movzbl %r12b, %edx
movq %r13, %rdi
leaq 0x28d20(%rip), %rsi     # 0x2fd46
xorl %eax, %eax
callq 0x4240
jmp 0x703b
movsbl %r12b, %edi
movq %r13, %rsi
callq 0x41f0
cmpl $0x7, %r15d
setne %al
cmpq $0x1, %rbx
setne %cl
testb %al, %cl
jne 0x7066
movl $0x2, %esi
movl $0x1, %edx
leaq 0x2959e(%rip), %rdi     # 0x305fc
movq %r13, %rcx
callq 0x4330
incq %rbp
decq %rbx
jne 0x6fac
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x291f7(%rip), %rdi     # 0x30283
leaq 0x290b9(%rip), %rsi     # 0x3014c
leaq 0x291f1(%rip), %rcx     # 0x3028b
movl $0xc5, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: mkinsnv
static Insn *
mkinsnv(AsmOp op, va_list ap)
{
	Loc *l;
	Insn *i;
	int n;
	static size_t insnid;

	n = 0;
	i = malloc(sizeof(Insn));
	i->op = op;
	i->uid = insnid++;
	while ((l = va_arg(ap, Loc*)) != NULL)
		i->args[n++] = l;
	i->nargs = n;
	return i;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x38, %edi
callq 0x4280
movl %ebp, 0x8(%rax)
movq 0x5976c(%rip), %rcx     # 0x60e78
leaq 0x1(%rcx), %rdx
movq %rdx, 0x59761(%rip)     # 0x60e78
movq %rcx, (%rax)
movl (%rbx), %edx
xorl %ecx, %ecx
cmpl $0x28, %edx
ja 0x7730
movl %edx, %esi
addq 0x10(%rbx), %rsi
addl $0x8, %edx
movl %edx, (%rbx)
jmp 0x773c
movq 0x8(%rbx), %rsi
leaq 0x8(%rsi), %rdi
movq %rdi, 0x8(%rbx)
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x774e
movq %rsi, 0x10(%rax,%rcx,8)
incq %rcx
jmp 0x771e
movl %ecx, %ecx
movq %rcx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: binop
static Loc *
binop(Isel *s, AsmOp op, Node *x, Node *y)
{
	Loc *a, *b;

	a = selexpr(s, x);
	b = selexpr(s, y);
	a = newr(s, a);
	g(s, op, b, a, NULL);
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rsi
callq 0x775b
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x775b
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x8e9c
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8dc2
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: rolop
static Loc*
rolop(Isel *s, Node *n, Node *l, Node *r)
{
	int64_t lv, rv;
	Type *ty;

	ty = tybase(exprtype(n));

	if (!istyunsigned(ty))
		return NULL;
	if (exprop(l) != Obsl && exprop(l) != Obsr)
		return NULL;
	if (exprop(r) != Obsl && exprop(r) != Obsr)
		return NULL;
	if (exprop(r) == exprop(l))
		return NULL;
	if (exprop(l->expr.args[0]) != Ovar)
		return NULL;
	if (exprop(r->expr.args[0]) != Ovar)
		return NULL;
	if (l->expr.args[0]->expr.did != r->expr.args[0]->expr.did)
		return NULL;

	if (exprop(l->expr.args[1]) != Olit)
		return NULL;
	if (l->expr.args[1]->expr.args[0]->type != Nlit)
		return NULL;
	if (l->expr.args[1]->expr.args[0]->lit.littype != Lint)
		return NULL;
	lv = l->expr.args[1]->expr.args[0]->lit.intval;

	if (exprop(r->expr.args[1]) != Olit)
		return NULL;
	if (r->expr.args[1]->expr.args[0]->type != Nlit)
		return NULL;
	if (r->expr.args[1]->expr.args[0]->lit.littype != Lint)
		return NULL;
	rv = r->expr.args[1]->expr.args[0]->lit.intval;

	if (lv + rv != 8*size(n))
		return NULL;

	if (exprop(l) == Obsl)
		return binop(s, Irol, l->expr.args[0], l->expr.args[1]);
	else
		return binop(s, Irol, r->expr.args[0], r->expr.args[1]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1e384
movq %rax, %rdi
callq 0x227ac
movq %rax, %rdi
callq 0x22f93
testl %eax, %eax
je 0x8db1
movq %r15, %rdi
callq 0x1d422
cmpl $0xb, %eax
je 0x8c87
movq %r15, %rdi
callq 0x1d422
cmpl $0xc, %eax
jne 0x8db1
movq %r14, %rdi
callq 0x1d422
cmpl $0xb, %eax
je 0x8ca5
movq %r14, %rdi
callq 0x1d422
cmpl $0xc, %eax
jne 0x8db1
movq %r14, %rdi
callq 0x1d422
movl %eax, %ebp
movq %r15, %rdi
callq 0x1d422
cmpl %eax, %ebp
je 0x8db1
movq 0x50(%r15), %rax
movq (%rax), %rdi
callq 0x1d422
cmpl $0x33, %eax
jne 0x8db1
movq 0x50(%r14), %rax
movq (%rax), %rdi
callq 0x1d422
cmpl $0x33, %eax
jne 0x8db1
leaq 0x50(%r15), %r13
addq $0x50, %r14
movq (%r13), %rax
movq (%rax), %rcx
movq 0x38(%rcx), %rcx
movq (%r14), %rdx
movq (%rdx), %rdx
cmpq 0x38(%rdx), %rcx
jne 0x8db1
movq 0x8(%rax), %rdi
callq 0x1d422
cmpl $0x35, %eax
jne 0x8db1
movq (%r13), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x8db1
cmpl $0x2, 0x18(%rax)
jne 0x8db1
movq 0x30(%rax), %rbp
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x1d422
cmpl $0x35, %eax
jne 0x8db1
movq (%r14), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x8db1
cmpl $0x2, 0x18(%rax)
jne 0x8db1
addq 0x30(%rax), %rbp
movq %r12, %rdi
callq 0x12664
shlq $0x3, %rax
cmpq %rax, %rbp
jne 0x8db1
movq %r15, %rdi
callq 0x1d422
cmpl $0xb, %eax
cmoveq %r13, %r14
movq (%r14), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rbx, %rdi
movl $0x18, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8bd9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: g
static void
g(Isel *s, int op, ...)
{
	va_list ap;
	Insn *i;

	va_start(ap, op);
	i = mkinsnv(op, ap);
	va_end(ap);
	if (debugopt['i']) {
		printf("GEN[uid=%zd] ", i->uid);
		dbgiprintf(stdout, i);
	}
	lappend(&s->curbb->il, &s->curbb->ni, i);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movl %esi, %r10d
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x8e22
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rsi
movq %rdi, 0x10(%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsi)
movl %r10d, %edi
callq 0x76f0
movq %rax, %r14
leaq 0x5838c(%rip), %rax     # 0x611e0
cmpb $0x0, 0x69(%rax)
je 0x8e7d
movq (%r14), %rsi
leaq 0x27c90(%rip), %rdi     # 0x30af4
xorl %eax, %eax
callq 0x4140
movq 0x3b15e(%rip), %rax     # 0x43fd0
movq (%rax), %rdi
movq %r14, %rsi
callq 0x6757
movq 0x28(%rbx), %rsi
leaq 0x18(%rsi), %rdi
addq $0x20, %rsi
movq %r14, %rdx
callq 0x2ceff
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: newr
static Loc *
newr(Isel *s, Loc *a)
{
	Loc *r;

	r = locreg(a->mode);
	if (a->type == Locreg) {
		if (isfloatmode(a->mode))
			g(s, Imovs, a, r, NULL);
		else
			g(s, Imov, a, r, NULL);
	} else {
		load(s, a, r);
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsi), %edi
callq 0xa8da
movq %rax, %rbx
cmpl $0x2, (%r14)
jne 0x8ecf
movl 0x4(%r14), %edi
callq 0xa7a3
movq %r15, %rdi
testl %eax, %eax
je 0x8edf
movl $0x27, %esi
jmp 0x8ee4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa1d2
jmp 0x8ef4
movl $0x1, %esi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8dc2
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: mode
static Mode
mode(Node *n)
{
	if (n->type == Nexpr)
		return tymode(exprtype(n));
	else if (n->type == Ndecl)
		return tymode(n->decl.type);
	else
		die("invalid node type");
	return ModeNone;
}

// Assembly:
pushq %rax
movl 0x8(%rdi), %eax
cmpl $0xb, %eax
je 0x8f15
cmpl $0x8, %eax
jne 0x8f1f
callq 0x1e384
movq %rax, %rdi
jmp 0x8f19
movq 0x28(%rdi), %rdi
popq %rax
jmp 0xa24b
leaq 0x27c0e(%rip), %rdi     # 0x30b34
xorl %eax, %eax
callq 0x13844