LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
setbe %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x7640
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
addq $0x1, %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
subq -0x10(%rbp), %rdx
shlq $0x4, %rdx
callq 0x6420
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jbe 0x19b64
cmpq $0x0, -0x10(%rbp)
jbe 0x19b00
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x19ae6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x19b62
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x19b4a
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x19b64
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/lib1.c
// Function: bptree_leaf_locate
static u64
bptree_leaf_locate(struct bpnode * const node, const struct kv * const key)
{
  if (node->nr < 2) {
    return 0;
  }
  u64 l = 0;
  u64 r = node->nr - 1;
  while (l < r) {
    const u64 m = (l + r + 1) >> 1;
    const int cmp = kv_keycompare(key, node->karray[m]);
    if (cmp < 0) {
      r = m - 1;
    } else if (cmp > 0) {
      l = m;
    } else {
      return m;
    }
  }
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x2, 0x8(%rax)
jae 0x19b98
movq $0x0, -0x8(%rbp)
jmp 0x19c20
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x19c18
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
addq $0x1, %rax
shrq %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x20(%rax,%rcx,8), %rsi
callq 0xe250
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x19bfa
movq -0x30(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x19c16
cmpl $0x0, -0x34(%rbp)
jle 0x19c0a
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x19c14
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19c20
jmp 0x19c16
jmp 0x19bb0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/lib1.c
// Function: bptree_raw_insert_leaf
static void
bptree_raw_insert_leaf(struct bpnode * const leaf, const u64 idx, const struct kv * const kv)
{
  debug_assert(idx <= leaf->nr);
  memmove(&(leaf->karray[idx + 1]), &(leaf->karray[idx]), sizeof(leaf->karray[0]) * (leaf->nr - idx));
  leaf->karray[idx] = kv;
  leaf->nr++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
setbe %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x7640
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
addq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
subq -0x10(%rbp), %rdx
shlq $0x3, %rdx
callq 0x6420
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rdx, 0x20(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/lib1.c
// Function: bptree_split_leaf
static void
bptree_split_leaf(struct bpnode * const parent, const u64 subidx)
{
  debug_assert(parent->nr < BPTREE_INTM_FO);
  struct bpnode * const left = parent->iarray[subidx].sub;
  struct bpnode * const right = bptree_alloc_node(true);
  (void)bptree_raw_balance_leaf(left, right);

  const u64 insert = subidx + 1;
  bptree_raw_insert_intm(parent, insert, kv_dup_key(right->karray[0]), right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0xfa, 0x8(%rax)
setb %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x7640
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %edi
callq 0x13920
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13b00
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xdf40
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x199d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/lib1.c
// Function: bptree_split_intm
static void
bptree_split_intm(struct bpnode * const parent, const u64 subidx)
{
  debug_assert(parent->nr < BPTREE_INTM_FO);
  struct bpnode * const left = parent->iarray[subidx].sub;
  struct bpnode * const right = bptree_alloc_node(false);
  (void)bptree_raw_balance_intm(left, right);

  const u64 insert = subidx + 1;
  bptree_raw_insert_intm(parent, insert, kv_dup_key(right->iarray[0].key), right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0xfa, 0x8(%rax)
setb %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x7640
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %edi, %edi
callq 0x13920
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13c60
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xdf40
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x199d0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/lib1.c
// Function: icache_refresh
static inline void
icache_refresh(struct icache * const cache, const struct kv * const old, const struct kv * const new)
{
  const u64 hash = new->hash;
  const u64 idx = (hash >> KVMAP_BASE_LEVEL) % cache->nr_slots;
  struct __icache_slot * const slot = &(cache->table[idx]);
  for (u64 i = 0; i < ICACHE_ENTRY_NR; i++) {
    struct kv * const curr = __u64_to_ptr(slot->e[i].ptr);
    if (curr == old) {
      icache_put_entry(&(slot->e[i]), new);
      return;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x6, %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq 0x10120(%rcx)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10130(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x7, -0x38(%rbp)
jae 0x1a013
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
shrq $0x10, %rdi
callq 0xf220
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x1a003
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x38(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x16520
jmp 0x1a013
jmp 0x1a005
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x19fba
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x38, %edi
callq 0x48160
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/blob.c
// Function: mkblobpad
Blob *
mkblobpad(size_t sz)
{
	Blob *b;

	b = zalloc(sizeof(Blob));
	b->type = Btpad;
	b->npad = sz;
	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x38, %edi
callq 0x48160
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x8, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x38, %edi
callq 0x48160
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x38, %edi
callq 0x48160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x5, (%rax)
movq -0x8(%rbp), %rdi
callq 0x6330
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6625
jmp 0x6694
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x5, %eax
je 0x663f
jmp 0x6635
movl -0x14(%rbp), %eax
subl $0x7, %eax
je 0x664e
jmp 0x6689
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6040
jmp 0x668b
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x6687
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6610
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6656
jmp 0x668b
jmp 0x668b
movq -0x8(%rbp), %rdi
callq 0x6040
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/blob.c
// Function: blobucon
static size_t
blobucon(Blob *seq, Htab *globls, Htab *strtab, Node *n)
{
	size_t sz, align;
	Ucon *uc;

	sz = 4;
	uc = finducon(exprtype(n), n->expr.args[0]);
	b(seq, mkblobi(Bti32, uc->id));
	align = 1;
	if (n->expr.nargs > 1) {
		align = tyalign(exprtype(n->expr.args[1]));
		if (align > sz)
			sz += blobpad(seq, align - sz);
		sz += blobrec(seq, globls, strtab, n->expr.args[1]);
	}
	sz += blobpad(seq, size(n) - sz);
	return sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x4, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
callq 0x377a0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x2, %edi
callq 0x6480
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x66a0
movq $0x1, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x1, 0x40(%rax)
jbe 0x6bfe
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x1c4c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x6bd9
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
subq -0x28(%rbp), %rsi
callq 0x7410
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rcx
callq 0x6730
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c480
movq -0x48(%rbp), %rdi
movq %rax, %rsi
subq -0x28(%rbp), %rsi
callq 0x7410
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/blob.c
// Function: blobslice
static size_t
blobslice(Blob *seq,  Htab *globls, Htab *strtab, Node *n)
{
	Node *base, *lo, *hi;
	vlong loval, hival, baseval, sz;
	Blob *slbase;
	char *lbl;

	base = n->expr.args[0];
	lo = n->expr.args[1];
	hi = n->expr.args[2];

	/* by this point, all slicing operations should have had their base
	 * pulled out, and we should have vars with their pseudo-decls in their
	 * place */
	if (!getintlit(lo, &loval))
		fatal(lo, "lower bound in slice is not constant literal");
	if (!getintlit(hi, &hival))
		fatal(hi, "upper bound in slice is not constant literal");
	if (exprop(base) == Ovar && base->expr.isconst) {
		sz = tysize(tybase(exprtype(base))->sub[0]);
		lbl = htget(globls, base);
		slbase = mkblobref(lbl, loval*sz, 1);
	} else if (exprop(base) == Olit || exprop(base) == Oarr) {
		if (!getintlit(base, &baseval))
			fatal(base, "invalid base expr");
		slbase = mkblobi(Bti64, baseval);
	} else {
		fatal(base, "slice base is not a constant value");
	}

	b(seq, slbase);
	b(seq, mkblobi(Bti64, (hival - loval)));
	return 16;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1f230
cmpl $0x0, %eax
jne 0x6cab
movq -0x30(%rbp), %rdi
leaq 0x44410(%rip), %rsi     # 0x4b0b4
movb $0x0, %al
callq 0x1dfe0
movq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1f230
cmpl $0x0, %eax
jne 0x6ccf
movq -0x38(%rbp), %rdi
leaq 0x44419(%rip), %rsi     # 0x4b0e1
movb $0x0, %al
callq 0x1dfe0
movq -0x28(%rbp), %rdi
callq 0x2f210
cmpl $0x33, %eax
jne 0x6d36
movq -0x28(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x6d36
movq -0x28(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
movq 0x68(%rax), %rax
movq (%rax), %rdi
callq 0x1c0f0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x49490
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq -0x40(%rbp), %rsi
imulq -0x58(%rbp), %rsi
movl $0x1, %edx
callq 0x65a0
movq %rax, -0x60(%rbp)
jmp 0x6d9e
movq -0x28(%rbp), %rdi
callq 0x2f210
cmpl $0x35, %eax
je 0x6d52
movq -0x28(%rbp), %rdi
callq 0x2f210
cmpl $0x39, %eax
jne 0x6d8a
movq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1f230
cmpl $0x0, %eax
jne 0x6d76
movq -0x28(%rbp), %rdi
leaq 0x4439f(%rip), %rsi     # 0x4b10e
movb $0x0, %al
callq 0x1dfe0
movq -0x50(%rbp), %rsi
movl $0x3, %edi
callq 0x6480
movq %rax, -0x60(%rbp)
jmp 0x6d9c
movq -0x28(%rbp), %rdi
leaq 0x4438b(%rip), %rsi     # 0x4b120
movb $0x0, %al
callq 0x1dfe0
jmp 0x6d9e
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x66a0
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x48(%rbp), %rsi
subq -0x40(%rbp), %rsi
movl $0x3, %edi
callq 0x6480
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x66a0
movl $0x10, %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/blob.c
// Function: blobstruct
static size_t
blobstruct(Blob *seq, Htab *globls, Htab *strtab, Node *n)
{
	size_t i, sz, pad, end, ndcl;
	Node **dcl, *m;
	Type *t;

	sz = 0;
	t = tybase(exprtype(n));
	assert(t->type == Tystruct);
	dcl = t->sdecls;
	ndcl = t->nmemb;

	for (i = 0; i < ndcl; i++) {
		pad = alignto(sz, decltype(dcl[i]));
		m = structmemb(n, declname(dcl[i]));
		sz += blobpad(seq, pad - sz);
		if (m)
			sz += blobrec(seq, globls, strtab, m);
		else
			sz += blobpad(seq, size(dcl[i]));
	}
	end = alignto(sz, t);
	sz += blobpad(seq, end - sz);
	return sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpl $0x17, (%rax)
jne 0x6e23
jmp 0x6e42
leaq 0x44319(%rip), %rdi     # 0x4b143
leaq 0x44326(%rip), %rsi     # 0x4b157
movl $0xe8, %edx
leaq 0x44321(%rip), %rcx     # 0x4b15e
callq 0x6160
movq -0x60(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x60(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x6f44
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30260
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x16770
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30200
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x7450
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
subq -0x30(%rbp), %rsi
callq 0x7410
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x6f04
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0x6730
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x6f31
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1c480
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x7410
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x6f33
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6e65
movq -0x30(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x16770
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
subq -0x30(%rbp), %rsi
callq 0x7410
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/blob.c
// Function: blobvar
static size_t
blobvar(Blob *seq, Htab *strtab, Node *var, Type *ty)
{
	Node *dcl;
	Ty tt;

	dcl = decls[var->expr.did];
	tt = tybase(ty)->type;
	if ((tt != Tyfunc && tt != Tycode)|| !dcl->decl.isglobl)
		fatal(var, "non-constant initializer %s", namestr(var->expr.args[0]));
	b(seq, mkblobi(Bti64, 0));
	b(seq, mkblobref(asmname(dcl), 0, 1));
	return 16;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x764e9(%rip), %rax     # 0x7d488
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x36a30
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x13, -0x2c(%rbp)
je 0x6fcc
cmpl $0x1e, -0x2c(%rbp)
jne 0x6fd6
movq -0x28(%rbp), %rax
cmpb $0x0, 0x71(%rax)
jne 0x7003
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdi
callq 0x30600
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x44194(%rip), %rsi     # 0x4b190
movb $0x0, %al
callq 0x1dfe0
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x3, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x6480
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x66a0
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7720
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x65a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x66a0
movl $0x10, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/blob.c
// Function: structmemb
static Node *
structmemb(Node *n, char *dcl)
{
	size_t i;

	for (i = 0; i < n->expr.nargs; i++)
		if (!strcmp(namestr(n->expr.args[i]->expr.idx), dcl))
			return n->expr.args[i];
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x74c6
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x48(%rax), %rdi
callq 0x30600
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x6220
cmpl $0x0, %eax
jne 0x74b6
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x74ce
jmp 0x74b8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7468
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x49720
movq %rax, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x7594
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x49490
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x41010
cmpl $0x0, %eax
je 0x755a
movq -0x50(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x76a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x7720
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x49100
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x750d
movq -0x38(%rbp), %rdi
callq 0x6040
leaq 0x757f4(%rip), %rax     # 0x7cd98
movq 0xa0(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x49720
movq %rax, -0x40(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x7686
leaq 0x757c3(%rip), %rax     # 0x7cd98
movq 0xa0(%rax), %rdi
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x49490
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x49720
movq %rax, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x766c
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x49490
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rdi
callq 0x7720
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0x49100
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x760e
movq -0x38(%rbp), %rdi
callq 0x6040
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x75c0
movq -0x40(%rbp), %rdi
callq 0x6040
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36a30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1e, (%rax)
jne 0x76cc
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7715
movq -0x10(%rbp), %rax
cmpl $0x13, (%rax)
jne 0x76d7
jmp 0x76f6
leaq 0x43b51(%rip), %rdi     # 0x4b22f
leaq 0x43b5d(%rip), %rsi     # 0x4b242
movl $0x51, %edx
leaq 0x43b57(%rip), %rcx     # 0x4b248
callq 0x6160
movq -0x10(%rbp), %rdi
callq 0x36d20
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1e, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x440(%rbp)
leaq 0x4e0e0(%rip), %rax     # 0x55825
movq %rax, -0x420(%rbp)
movq -0x440(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x428(%rbp)
movq -0x440(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x430(%rbp)
leaq 0x4e0ae(%rip), %rax     # 0x55825
movq %rax, -0x418(%rbp)
leaq 0x4e0a0(%rip), %rax     # 0x55825
movq %rax, -0x438(%rbp)
leaq 0x75555(%rip), %rax     # 0x7cce8
cmpl $0x2, (%rax)
jne 0x77b6
movq -0x8(%rbp), %rdi
callq 0x7b20
cmpl $0x0, %eax
je 0x77b4
leaq 0x44b65(%rip), %rax     # 0x4c312
movq %rax, -0x418(%rbp)
jmp 0x77b6
cmpq $0x0, -0x428(%rbp)
je 0x77cc
movq -0x428(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x77dc
leaq 0x4e052(%rip), %rax     # 0x55825
movq %rax, -0x428(%rbp)
jmp 0x77ea
leaq 0x43a96(%rip), %rax     # 0x4b279
movq %rax, -0x438(%rbp)
movq -0x430(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x7807
leaq 0x4e025(%rip), %rax     # 0x55825
movq %rax, -0x420(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x420(%rbp), %rcx
movq -0x428(%rbp), %r8
movq -0x438(%rbp), %r9
movq -0x430(%rbp), %r10
movq -0x418(%rbp), %rax
movl $0x400, %esi            # imm = 0x400
leaq 0x43a3e(%rip), %rdx     # 0x4b27b
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x4a230
leaq -0x410(%rbp), %rdi
callq 0x6330
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x24(%rbp)
movq -0x28(%rbp), %rdi
movl $0xe, %esi
callq 0x36c10
movq %rax, %rcx
leaq 0x755a6(%rip), %rax     # 0x7ce48
movq %rcx, (%rax)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x2c(%rbp)
movq -0x30(%rbp), %rdi
movl $0xc, %esi
callq 0x36c10
movq %rax, %rcx
leaq 0x75585(%rip), %rax     # 0x7ce50
movq %rcx, (%rax)
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x34(%rbp)
movq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x36c10
movq %rax, %rcx
leaq 0x75564(%rip), %rax     # 0x7ce58
movq %rcx, (%rax)
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x3c(%rbp)
movl $0xffffffff, -0x48(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x44(%rbp)
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x36c10
movq %rax, %rcx
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x37520
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1e, (%rax)
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x4c(%rbp)
movq -0x50(%rbp), %rdi
leaq 0x438c6(%rip), %rsi     # 0x4b221
leaq 0x438c3(%rip), %rdx     # 0x4b225
callq 0x2fec0
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x58(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x54(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x58(%rbp), %rdi
callq 0x2ff20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x72(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x74(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7720
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0x49100
movl $0xffffffff, -0x60(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x5c(%rbp)
movq -0x18(%rbp), %rdx
movq -0x60(%rbp), %rdi
movl $0x33, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, %rcx
leaq 0x75469(%rip), %rax     # 0x7ce60
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
leaq 0x7545b(%rip), %rax     # 0x7ce60
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x75445(%rip), %rax     # 0x7ce60
movq (%rax), %rax
movq %rcx, 0x38(%rax)
leaq 0x75437(%rip), %rax     # 0x7ce60
movq (%rax), %rax
movl $0x1, 0x30(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36a30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x13, (%rax)
jne 0x7a6c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7ab5
movq -0x10(%rbp), %rax
cmpl $0x1e, (%rax)
jne 0x7a77
jmp 0x7a96
leaq 0x4d62f(%rip), %rdi     # 0x550ad
leaq 0x437bd(%rip), %rsi     # 0x4b242
movl $0x5d, %edx
leaq 0x437ce(%rip), %rcx     # 0x4b25f
callq 0x6160
movq -0x10(%rbp), %rdi
callq 0x36d20
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x13, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/gen.c
// Function: islocal
static int
islocal(Node *dcl)
{
	if (dcl->decl.vis != Visintern)
		return 0;
	if (dcl->decl.isimport || dcl->decl.isextern)
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x70(%rax), %eax
cmpl $0x0, %eax
je 0x7b3e
movl $0x0, -0x4(%rbp)
jmp 0x7b68
movq -0x10(%rbp), %rax
movsbl 0x77(%rax), %eax
cmpl $0x0, %eax
jne 0x7b58
movq -0x10(%rbp), %rax
movsbl 0x74(%rax), %eax
cmpl $0x0, %eax
je 0x7b61
movl $0x0, -0x4(%rbp)
jmp 0x7b68
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x438c8(%rip), %rsi     # 0x4b63f
callq 0x62d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7d99
movq -0x8(%rbp), %rsi
leaq 0x43524(%rip), %rdi     # 0x4b2b6
movb $0x0, %al
callq 0x1df20
leaq 0x74f48(%rip), %rax     # 0x7cce8
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2, %eax
jb 0x7dc1
jmp 0x7dac
movl -0x14(%rbp), %eax
subl $0x2, %eax
jne 0x7dcc
jmp 0x7db6
movq -0x10(%rbp), %rdi
callq 0x9460
jmp 0x7dda
movq -0x10(%rbp), %rdi
callq 0x8a30
jmp 0x7dda
leaq 0x434f7(%rip), %rdi     # 0x4b2ca
movb $0x0, %al
callq 0x1df20
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x7e25
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x7e23
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x4376d(%rip), %rsi     # 0x4b589
movb $0x0, %al
callq 0x6230
jmp 0x7e4c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7e4a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x4ac58(%rip), %rsi     # 0x52a9b
movb $0x0, %al
callq 0x6230
jmp 0x7e4c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x7ef8
movq -0x8(%rbp), %rdi
leaq 0x49444(%rip), %rsi     # 0x512aa
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x72, %edx
callq 0x7f20
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x7eb6
movq -0x8(%rbp), %rdi
leaq 0x4d523(%rip), %rsi     # 0x553bc
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movl $0x72, %edx
callq 0x7f20
movq -0x10(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jle 0x7ed9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
leaq 0x4344a(%rip), %rsi     # 0x4b31c
movb $0x0, %al
callq 0x6230
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x7ef6
movq -0x8(%rbp), %rdi
leaq 0x4b4f8(%rip), %rsi     # 0x533e7
movb $0x0, %al
callq 0x6230
jmp 0x7f11
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
je 0x7f0f
leaq 0x43418(%rip), %rdi     # 0x4b320
movb $0x0, %al
callq 0x1df20
jmp 0x7f11
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x49720
movq %rax, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x856b
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x49490
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x4357b(%rip), %rsi     # 0x4bab9
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x8580
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x84f9
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x86b7
movq -0x20(%rbp), %rax
movl $0x3c, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x85d0
movq -0x8(%rbp), %rdi
leaq 0x434cf(%rip), %rsi     # 0x4ba98
movb $0x0, %al
callq 0x6230
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
je 0x85f2
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x8604
movq -0x8(%rbp), %rdi
leaq 0x434a5(%rip), %rsi     # 0x4baa2
movb $0x0, %al
callq 0x6230
callq 0x6370
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x8649
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq 0x4b4f4(%rip), %rsi     # 0x53b34
movb $0x0, %al
callq 0x6230
jmp 0x866d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %edx
andl $0xff, %edx
leaq 0x4343e(%rip), %rsi     # 0x4baa4
movb $0x0, %al
callq 0x6230
movq -0x20(%rbp), %rax
movl $0x3c, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x3b, %rdx
je 0x8692
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x86a4
movq -0x8(%rbp), %rdi
leaq 0x43b77(%rip), %rsi     # 0x4c214
movb $0x0, %al
callq 0x6230
jmp 0x86a6
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x859c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xb, 0x8(%rax)
jne 0x86e4
jmp 0x8703
leaq 0x42cc2(%rip), %rdi     # 0x4b3ad
leaq 0x42c7b(%rip), %rsi     # 0x4b36d
movl $0x194, %edx            # imm = 0x194
leaq 0x42cc3(%rip), %rcx     # 0x4b3c1
callq 0x6160
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x49490
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x70(%rax), %eax
cmpl $0x0, %eax
je 0x8737
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x42cbe(%rip), %rsi     # 0x4b3ee
movb $0x0, %al
callq 0x6230
leaq 0x745aa(%rip), %rax     # 0x7cce8
cmpl $0x0, (%rax)
jne 0x8759
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x42ca7(%rip), %rsi     # 0x4b3f9
movb $0x0, %al
callq 0x6230
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x87d9
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30260
movq %rax, %rdi
callq 0x1c4c0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x42c90(%rip), %rsi     # 0x4b41b
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x43318(%rip), %rsi     # 0x4bab9
movb $0x0, %al
callq 0x6230
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x66e0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8820
movq -0x30(%rbp), %rdi
callq 0x6610
jmp 0x880b
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c480
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
leaq 0x42c23(%rip), %rsi     # 0x4b427
movb $0x0, %al
callq 0x6230
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/gengas.c
// Function: genfunc
static void
genfunc(FILE *fd, Func *fn, Htab *globls, Htab *strtab)
{
	Isel is = {0,};
	char cwd[1024];

	resetregs();
	if (!getcwd(cwd, sizeof cwd))
		die("getcwd failed: %s\n", cwd);
	is.reglocs = mkht(varhash, vareq);
	is.name = fn->name;
	is.stkoff = fn->stkoff;
	is.envoff = fn->envoff;
	is.globls = globls;
	is.ret = fn->ret;
	is.rettype = fn->rettype;
	is.cfg = fn->cfg;
	is.cwd = strdup(cwd);

	if (fn->hasenv)
		is.envp = locreg(ModeQ);

	selfunc(&is, fn, globls, strtab);
	if (debugopt['i'])
		writeasm(stdout, &is, fn);
	writeasm(fd, &is, fn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x4f0(%rbp), %rdi
xorl %esi, %esi
movl $0x4d0, %edx            # imm = 0x4D0
callq 0x6180
callq 0xfef0
leaq -0x8f0(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x6190
cmpq $0x0, %rax
jne 0x8e0f
leaq -0x8f0(%rbp), %rsi
leaq 0x42d6f(%rip), %rdi     # 0x4bb77
movb $0x0, %al
callq 0x1df20
leaq 0x279ba(%rip), %rdi     # 0x307d0
leaq 0x27a83(%rip), %rsi     # 0x308a0
callq 0x48fe0
movq %rax, -0x4a8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x4f0(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x4a0(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x498(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x490(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x4c0(%rbp)
movq -0x10(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x4b8(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x4e0(%rbp)
leaq -0x8f0(%rbp), %rdi
callq 0x6330
movq %rax, -0x4e8(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x59(%rax)
je 0x8eb9
movl $0x4, %edi
callq 0xff10
movq %rax, -0x488(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x4f0(%rbp), %rdi
callq 0xe1e0
leaq 0x73e28(%rip), %rax     # 0x7cd00
cmpb $0x0, 0x69(%rax)
je 0x8ef8
movq 0x560eb(%rip), %rax     # 0x5efd0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq -0x4f0(%rbp), %rsi
callq 0x9200
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x4f0(%rbp), %rsi
callq 0x9200
addq $0x8f0, %rsp            # imm = 0x8F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/gengas.c
// Function: gentypes
static void
gentypes(FILE *fd)
{
	Type *ty;
	size_t i;

	for (i = Ntypes; i < ntypes; i++) {
		if (!types[i]->isreflect)
			continue;
		ty = tydedup(types[i]);
		if (ty->isemitted || ty->isimport)
			continue;
		gentype(fd, ty);
	}
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x1f, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x74dc1(%rip), %rcx     # 0x7dd00
cmpq (%rcx), %rax
jae 0x8fbc
leaq 0x74da5(%rip), %rax     # 0x7dcf0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpb $0x0, 0x95(%rax)
jne 0x8f61
jmp 0x8fab
leaq 0x74d88(%rip), %rax     # 0x7dcf0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x36b70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x96(%rax), %eax
cmpl $0x0, %eax
jne 0x8f9c
movq -0x10(%rbp), %rax
movsbl 0x94(%rax), %eax
cmpl $0x0, %eax
je 0x8f9e
jmp 0x8fab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x93b0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x8f34
movq -0x8(%rbp), %rdi
leaq 0x44bef(%rip), %rsi     # 0x4dbb6
movb $0x0, %al
callq 0x6230
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/gengas.c
// Function: emitonce
static void
emitonce(FILE *fd, Blob *b)
{
	if (asmsyntax == Gnugaself) {
		fprintf(fd, ".section .text.%s%s,\"aG\",%s%s,comdat\n",
			Symprefix, b->lbl, Symprefix, b->lbl);
	} else if (asmsyntax == Gnugasmacho) {
		if (b->isglobl)
			fprintf(fd, ".weak_def_can_be_hidden %s%s\n", Symprefix, b->lbl);
	} else {
		die("Unknown asm flavor");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x73c91(%rip), %rax     # 0x7cce8
cmpl $0x0, (%rax)
jne 0x908a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %r9
leaq 0x42a9e(%rip), %rsi     # 0x4bb15
leaq 0x4c7a7(%rip), %r8      # 0x55825
movq %r8, %rdx
movb $0x0, %al
callq 0x6230
jmp 0x90d3
leaq 0x73c57(%rip), %rax     # 0x7cce8
cmpl $0x1, (%rax)
jne 0x90c3
movq -0x10(%rbp), %rax
cmpb $0x0, 0x18(%rax)
je 0x90c1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x42a88(%rip), %rsi     # 0x4bb3b
leaq 0x4c76b(%rip), %rdx     # 0x55825
movb $0x0, %al
callq 0x6230
jmp 0x90d1
leaq 0x42a8f(%rip), %rdi     # 0x4bb59
movb $0x0, %al
callq 0x1df20
jmp 0x90d3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)