LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: imm
static IR* imm(IReg* reg, int val) {
  IR* new = calloc(1, sizeof(IR));
  new->op = IIMM;
  new->r0 = reg;
  new->imm_int = val;
  return new;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x58
popq %rsi
callq 0x20f0
movq %r14, 0x10(%rax)
movl %ebx, 0x4(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: emit_lval
static IReg* emit_lval(Node* node) {
  switch (node->tag) {
  case NVAR: {
    IReg* addr = new_reg(8);
    emit_ir(address(addr, node->offset));
    return addr;
  }
  case NGVAR: {
    IReg* addr = new_reg(8);
    emit_ir(label(addr, node->name));
    return addr;
  }
  case NMEMBER: {
    IReg* addr = emit_lval(node->expr);
    IReg* offset = new_reg(8);
    emit_ir(imm(offset, field_offset(type_of(node->expr)->fields, node->name)));
    IReg* reg = new_reg(8);
    emit_ir(new_binop_ir(IADD, reg, addr, offset));
    return reg;
  }
  case NDEREF: {
    return emit_expr(node->expr);
  }
  default: {
    bad_token(node->token, "gen_ir error: emit_lval");
  }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1b, %eax
je 0x5c34
cmpl $0x2, %eax
je 0x5c95
cmpl $0x1a, %eax
je 0x5c20
cmpl $0x1, %eax
jne 0x5cd4
pushq $0x8
popq %rdi
callq 0x4c6a
movq %rax, %r14
movl 0x48(%rbx), %esi
movq %rax, %rdi
callq 0x4c91
jmp 0x5cbd
movq 0x38(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x526a
movq 0x38(%rbx), %rdi
callq 0x5bdc
movq %rax, %r15
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0x4c6a
movq %rax, %r12
movq 0x38(%rbx), %rdi
callq 0x76db
movq 0x30(%rax), %rdi
movq 0x40(%rbx), %rsi
callq 0x778e
movq %r12, %rdi
movl %eax, %esi
callq 0x5bb9
movq %rax, %rdi
callq 0x4c47
movq %r14, %rdi
callq 0x4c6a
movq %rax, %r14
pushq $0x2
popq %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x6c56
jmp 0x5cbd
pushq $0x8
popq %rdi
callq 0x4c6a
movq %rax, %r14
movq 0x40(%rbx), %rbx
pushq $0x1
popq %rdi
pushq $0x58
popq %rsi
callq 0x20f0
movl $0x1, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x28(%rax)
movq %rax, %rdi
callq 0x4c47
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rdi
leaq 0x6ff4(%rip), %rsi      # 0xccd3
callq 0xa124
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: load
static IR* load(IReg* dst, IReg* src) {
  IR* new = new_ir(ILOAD);
  new->r0 = dst;
  new->r1 = src;
  return new;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x13
popq %rdi
callq 0x6c44
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: move
static IR* move(IReg* dst, IReg* src) {
  IR* new = new_ir(IMOV);
  new->r0 = dst;
  new->r1 = src;
  return new;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x16
popq %rdi
callq 0x6c44
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/gen_x86.c
// Function: emit_const
static void emit_const(Type* type, Node* node) {
  if (!node) {
    return;
  }

  switch (node->tag) {
  case NINT: {
    if (size_of(type) == 1) {
      emit("db %d", node->integer);
    } else if (size_of(type) == 4) {
      emit("dd %d", node->integer);
    } else if (size_of(type) == 8) {
      emit("dq %d", node->integer);
    } else {
      bad_token(node->token, "emit error: emit_const(invalid size)");
    }
    break;
  }
  case NGVAR: {
    if (size_of(type) == 1) {
      emit("db %s", node->name);
    } else if (size_of(type) == 4) {
      emit("dd %s", node->name);
    } else if (size_of(type) == 8) {
      emit("dq %s", node->name);
    } else {
      bad_token(node->token, "emit error: emit_const(invalid size)");
    }
    break;
  }
  default:
    bad_token(node->token, "emit error: value is not constant");
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x6aa5
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
cmpl $0x2, %eax
je 0x6aad
testl %eax, %eax
jne 0x6b44
movq %r14, %rdi
callq 0x75fe
cmpq $0x1, %rax
jne 0x6ae3
movl 0x28(%rbx), %esi
leaq 0x6345(%rip), %rdi      # 0xcde5
jmp 0x6b39
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x75fe
cmpq $0x1, %rax
jne 0x6ac8
movq 0x40(%rbx), %rsi
leaq 0x6331(%rip), %rdi      # 0xcdf7
jmp 0x6b16
movq %r14, %rdi
callq 0x75fe
cmpq $0x4, %rax
jne 0x6afd
movq 0x40(%rbx), %rsi
leaq 0x631c(%rip), %rdi      # 0xcdfd
jmp 0x6b16
movq %r14, %rdi
callq 0x75fe
cmpq $0x4, %rax
jne 0x6b21
movl 0x28(%rbx), %esi
leaq 0x62f0(%rip), %rdi      # 0xcdeb
jmp 0x6b39
movq %r14, %rdi
callq 0x75fe
cmpq $0x8, %rax
jne 0x6b54
movq 0x40(%rbx), %rsi
leaq 0x62ed(%rip), %rdi      # 0xce03
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b64
movq %r14, %rdi
callq 0x75fe
cmpq $0x8, %rax
jne 0x6b54
movl 0x28(%rbx), %esi
leaq 0x62b8(%rip), %rdi      # 0xcdf1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b64
movq 0x8(%rbx), %rdi
leaq 0x5678(%rip), %rsi      # 0xc1c7
callq 0xa124
movq 0x8(%rbx), %rdi
leaq 0x5629(%rip), %rsi      # 0xc188
callq 0xa124
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/ir.c
// Function: new_binop_ir
IR* new_binop_ir(enum IRTag op, IReg* r0, IReg* r1, IReg* r2) {
  IR* new = new_ir(op);
  new->r0 = r0;
  new->r1 = r1;
  new->r2 = r2;
  return new;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x6c44
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/ir.c
// Function: count_stack_size
int count_stack_size(IFunc* func) {
  int size = 0;

  for (int i = 0; i < func->blocks->length; i++) {
    Block* block = func->blocks->ptr[i];

    for (int i = 0; i < block->instrs->length; i++) {
      IR* inst = block->instrs->ptr[i];

      if (inst->op == IALLOC) {
        size += inst->imm_int;
      }
    }
  }

  return size;
}

// Assembly:
movq 0x18(%rdi), %rcx
movq 0x10(%rcx), %rdx
xorl %esi, %esi
xorl %eax, %eax
cmpq %rdx, %rsi
je 0x6cbe
movq (%rcx), %rdi
movq (%rdi,%rsi,8), %rdi
movq 0x8(%rdi), %rdi
movq 0x10(%rdi), %r8
xorl %r9d, %r9d
cmpq %r9, %r8
je 0x6cb9
movq (%rdi), %r10
movq (%r10,%r9,8), %r10
cmpl $0x12, (%r10)
jne 0x6cb4
addl 0x4(%r10), %eax
incq %r9
jmp 0x6c9e
incq %rsi
jmp 0x6c87
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/ir.c
// Function: show_block
char* show_block(int* inst_count, Block* block) {
  StringBuilder* sb = new_sb();
  sb_puts(sb, format("%s: {\n", block->label));
  for (int i = 0; i < block->instrs->length; i++, (*inst_count)++) {
    sb_puts(sb, format(" [%d] ", *inst_count));
    sb_puts(sb, show_ir(block->instrs->ptr[i]));
    sb_puts(sb, "\n");
  }
  sb_puts(sb, "}");
  return sb_run(sb);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0xaa4f
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x5f6c(%rip), %rdi      # 0xd17b
xorl %eax, %eax
callq 0xa84a
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaac1
leaq 0x5f5a(%rip), %r12      # 0xd182
leaq 0x6291(%rip), %r13      # 0xd4c0
xorl %ebp, %ebp
movq 0x8(%r14), %rax
cmpq %rbp, 0x10(%rax)
jbe 0x7281
movl (%r15), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0xa84a
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaac1
movq 0x8(%r14), %rax
movq (%rax), %rax
movq (%rax,%rbp,8), %rdi
callq 0x6cde
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaac1
movq %rbx, %rdi
movq %r13, %rsi
callq 0xaac1
incq %rbp
incl (%r15)
jmp 0x7231
leaq 0x5f01(%rip), %rsi      # 0xd189
movq %rbx, %rdi
callq 0xaac1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaaf4
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/ir.c
// Function: show_ifunc
char* show_ifunc(IFunc* ifunc) {
  if (!ifunc->blocks) {
    return format("extern %s", ifunc->name);
  }

  StringBuilder* sb = new_sb();
  int inst_count = 0;
  sb_puts(sb, format("=== %s(%s) ===\n", ifunc->name, ifunc->entry_label));
  sb_puts(sb, "params: ");
  for (int i = 0; i < ifunc->params->length; i++) {
    sb_puts(sb, show_ireg(ifunc->params->ptr[i]));
    sb_puts(sb, " ");
  }
  sb_puts(sb, "\n");
  for (int i = 0; i < ifunc->blocks->length; i++) {
    sb_puts(sb, show_block(&inst_count, ifunc->blocks->ptr[i]));
    sb_puts(sb, "\n");
  }
  return sb_run(sb);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x739b
callq 0xaa4f
andl $0x0, 0xc(%rsp)
movq %rax, %r14
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x5eb9(%rip), %rdi      # 0xd195
xorl %r12d, %r12d
xorl %eax, %eax
callq 0xa84a
movq %r14, %rdi
movq %rax, %rsi
callq 0xaac1
leaq 0x5ead(%rip), %rsi      # 0xd1a5
movq %r14, %rdi
callq 0xaac1
leaq 0x4f46(%rip), %r15      # 0xc24d
movq 0x10(%rbx), %rax
cmpq %r12, 0x10(%rax)
jbe 0x7338
movq (%rax), %rax
movq (%rax,%r12,8), %rdi
callq 0x6cbf
movq %r14, %rdi
movq %rax, %rsi
callq 0xaac1
movq %r14, %rdi
movq %r15, %rsi
callq 0xaac1
incq %r12
jmp 0x7307
leaq 0x6181(%rip), %r15      # 0xd4c0
movq %r14, %rdi
movq %r15, %rsi
callq 0xaac1
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movq 0x18(%rbx), %rax
cmpq %r13, 0x10(%rax)
jbe 0x7386
movq (%rax), %rax
movq (%rax,%r13,8), %rsi
movq %r12, %rdi
callq 0x71ec
movq %r14, %rdi
movq %rax, %rsi
callq 0xaac1
movq %r14, %rdi
movq %r15, %rsi
callq 0xaac1
incq %r13
jmp 0x7352
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xaaf4
movq (%rbx), %rsi
leaq 0x5de6(%rip), %rdi      # 0xd18b
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xa84a
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/ir.c
// Function: show_iprog
char* show_iprog(IProgram* iprog) {
  StringBuilder* sb = new_sb();
  for (int i = 0; i < iprog->ifuncs->length; i++) {
    sb_puts(sb, show_ifunc(iprog->ifuncs->ptr[i]));
  }
  return sb_run(sb);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
callq 0xaa4f
movq %rax, %r14
movq (%rbx), %rax
cmpq %r15, 0x10(%rax)
jbe 0x73f1
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
callq 0x72a6
movq %r14, %rdi
movq %rax, %rsi
callq 0xaac1
incq %r15
jmp 0x73cc
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xaaf4
nop
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/node.c
// Function: new_node
Node *new_node(enum NodeTag tag, Token *token) {
  Node *node = calloc(1, sizeof(Node));
  node->tag = tag;
  node->token = token;
  return node;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x1
popq %rdi
movl $0x90, %esi
callq 0x20f0
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/node.c
// Function: new_type
Type *new_type(enum TypeTag tag, size_t size) {
  Type *ty = calloc(1, sizeof(Type));
  ty->ty = tag;
  ty->size = size;
  ty->align = size;
  return ty;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0x20f0
movl %ebp, (%rax)
movq %rbx, 0x10(%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/node.c
// Function: array_of
Type *array_of(Type *type, size_t size) {
  Type *array = ptr_to(type);
  array->array_size = size;
  array->size = size * size_of(type);
  return array;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x76a2
movq %rbx, 0x20(%rax)
imulq 0x10(%r14), %rbx
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/node.c
// Function: look_struct
Field *look_struct(Field *fields, char *name) {
  for (Field *f = fields; f != NULL; f = f->next) {
    if (streq(f->name, name)) {
      return f;
    }
  }
  for (Field *f = fields; f != NULL; f = f->next) {
    if (f->type->fields) {
      // Unnamed substructures
      Field *sub = look_struct(f->type->fields, name);
      if (sub) {
        Field *g = calloc(1, sizeof(Field));
        g->name = sub->name;
        g->type = sub->type;
        g->next = sub->next;
        g->offset = f->offset + sub->offset;
        return g;
      }
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq %rdi, %rbx
testq %rbx, %rbx
je 0x770b
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0xaa3e
testl %eax, %eax
jne 0x7760
movq (%rbx), %rbx
jmp 0x76f1
xorl %ebx, %ebx
testq %r14, %r14
je 0x7760
movq 0x10(%r14), %rax
movq 0x30(%rax), %rdi
testq %rdi, %rdi
je 0x772c
movq %r15, %rsi
callq 0x76e0
testq %rax, %rax
jne 0x7731
movq (%r14), %r14
jmp 0x770d
movq %rax, %r12
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x20f0
movq %rax, %rbx
movq 0x10(%r12), %rax
movq %rax, 0x10(%rbx)
movups (%r12), %xmm0
movups %xmm0, (%rbx)
movq 0x18(%r12), %rax
addq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/node.c
// Function: field_type
Type *field_type(Field *fields, char *name) {
  Field *field = look_struct(fields, name);
  if (!field)
    error("unreachable(field_type)");
  return field->type;
}

// Assembly:
pushq %rax
callq 0x76e0
testq %rax, %rax
je 0x7780
movq 0x10(%rax), %rax
popq %rcx
retq
leaq 0x5a45(%rip), %rdi      # 0xd1cc
xorl %eax, %eax
callq 0xa90e
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/node.c
// Function: field_offset
size_t field_offset(Field *fields, char *name) {
  Field *field = look_struct(fields, name);
  if (!field)
    error("unreachable(field_offset)");
  return field->offset;
}

// Assembly:
pushq %rax
callq 0x76e0
testq %rax, %rax
je 0x779f
movq 0x18(%rax), %rax
popq %rcx
retq
leaq 0x5a3e(%rip), %rdi      # 0xd1e4
xorl %eax, %eax
callq 0xa90e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: parse
Program *parse(Token *t) {
  tokens = t;

  init_typedef();

  Program *prog = calloc(1, sizeof(Program));
  prog->funcs = new_vec();

  while (tokens) {
    Function *func = toplevel();
    if (func) {
      vec_push(prog->funcs, func);
    }
  }

  prog->globals = global_env;

  return prog;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, 0xa996(%rip)      # 0x12158
callq 0x7678
leaq 0x5a30(%rip), %rdi      # 0xd1fe
movq %rax, %rsi
callq 0x7931
callq 0x7681
leaq 0x5a21(%rip), %rdi      # 0xd203
movq %rax, %rsi
callq 0x7931
callq 0x768c
leaq 0x5a12(%rip), %rdi      # 0xd208
movq %rax, %rsi
callq 0x7931
callq 0x7697
leaq 0x5a02(%rip), %rdi      # 0xd20c
movq %rax, %rsi
callq 0x7931
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x20f0
movq %rax, %rbx
xorl %eax, %eax
callq 0x229c
movq %rax, %r14
movq %rax, (%rbx)
leaq 0x59dd(%rip), %r15      # 0xd211
leaq 0x59de(%rip), %r12      # 0xd219
leaq 0x5b07(%rip), %rbp      # 0xd349
cmpq $0x0, 0xa90e(%rip)      # 0x12158
je 0x78f5
movq %r15, %rdi
callq 0x7967
testq %rax, %rax
je 0x78a3
callq 0x7db4
movq 0xa8ef(%rip), %rsi      # 0x12158
cmpl $0x2, 0x8(%rsi)
jne 0x7912
movq (%rsi), %rcx
movq 0x10(%rsi), %r13
movq %rcx, 0xa8d7(%rip)      # 0x12158
movq %rax, %rdi
callq 0x7d41
movq %r13, %rdi
movq %rax, %rsi
callq 0x7931
movq %rbp, %rdi
callq 0x7967
testq %rax, %rax
jne 0x7842
jmp 0x791e
movq %r12, %rdi
callq 0x7967
testq %rax, %rax
je 0x78c2
callq 0x799c
movq 0xa8a4(%rip), %rax      # 0x12160
movb $0x1, 0x28(%rax)
jmp 0x7842
leaq 0x5957(%rip), %rdi      # 0xd220
callq 0x7967
xorl %edi, %edi
testq %rax, %rax
setne %dil
callq 0x7ab0
testq %rax, %rax
je 0x7842
movq %r14, %rdi
movq %rax, %rsi
callq 0x22c6
jmp 0x7842
movq 0xa864(%rip), %rax      # 0x12160
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x590e(%rip), %rdi      # 0xd227
callq 0x7d21
movq 0xa833(%rip), %rsi      # 0x12158
leaq 0x5901(%rip), %rdi      # 0xd22d
callq 0x7d21
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: add_typedef
static void add_typedef(char *name, Type *type) {
  TypeDef *td = calloc(1, sizeof(TypeDef));
  td->name = name;
  td->type = type;
  td->next = typedefs;
  typedefs = td;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x20f0
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0xa813(%rip), %rcx      # 0x12168
movq %rcx, (%rax)
movq %rax, 0xa809(%rip)      # 0x12168
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: match
static Token *match(char *name) {
  if (peek_tag(0) == TRESERVED && streq(peek(0)->ident, name)) {
    Token *t = peek(0);
    consume();
    return t;
  } else {
    return NULL;
  }
}

// Assembly:
pushq %rax
movq 0xa7e9(%rip), %rax      # 0x12158
cmpl $0x3, 0x8(%rax)
jne 0x7998
movq %rdi, %rsi
movq 0x10(%rax), %rdi
callq 0xaa3e
testl %eax, %eax
je 0x7998
movq 0xa7cc(%rip), %rax      # 0x12158
movq (%rax), %rcx
movq %rcx, 0xa7c2(%rip)      # 0x12158
jmp 0x799a
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: global_var
static void global_var(void) {
  Type *type = type_specifier();

  while (match("*")) {
    type = ptr_to(type);
  }

  Token *tok = peek(0);
  char *name = read_ident();

  type = read_type_suffix(type);

  if (match("=")) {
    if (match("{")) {
      /* リスト初期化 */
      Vector *inits = new_vec();
      vec_push(inits, assign());
      while (match(",")) {
        vec_push(inits, assign());
      }
      if (!match("}")) {
        parse_error("}", peek(0));
      }
      add_gvar(tok, name, type, NULL, inits);
    } else {
      add_gvar(tok, name, type, expr(), NULL);
    }
  } else {
    add_gvar(tok, name, type, NULL, NULL);
  }

  if (!match(";")) {
    parse_error("global_var: ;", peek(0));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x7db4
movq %rax, %r14
leaq 0x5b1c(%rip), %rbx      # 0xd4cf
movq %rbx, %rdi
callq 0x7967
testq %rax, %rax
je 0x79cd
movq %r14, %rdi
callq 0x76a2
movq %rax, %r14
jmp 0x79b3
callq 0x8032
movq %rax, %rbx
movq %r14, %rdi
callq 0x7d41
movq %rax, %r14
leaq 0x58b6(%rip), %rdi      # 0xd29d
callq 0x7967
testq %rax, %rax
je 0x7a4e
leaq 0x5853(%rip), %rdi      # 0xd24b
callq 0x7967
testq %rax, %rax
je 0x7a58
xorl %eax, %eax
callq 0x229c
movq %rax, %r15
leaq 0x463b(%rip), %r12      # 0xc04e
callq 0x81f9
movq %r15, %rdi
movq %rax, %rsi
callq 0x22c6
movq %r12, %rdi
callq 0x7967
testq %rax, %rax
jne 0x7a13
leaq 0x5752(%rip), %rdi      # 0xd189
callq 0x7967
testq %rax, %rax
je 0x7a9d
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
jmp 0x7a68
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
jmp 0x7a66
callq 0x8e75
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x81ad
leaq 0x58d5(%rip), %rdi      # 0xd349
callq 0x7967
testq %rax, %rax
je 0x7a8a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xa6c7(%rip), %rsi      # 0x12158
leaq 0x57e2(%rip), %rdi      # 0xd27a
callq 0x7d21
movq 0xa6b4(%rip), %rsi      # 0x12158
leaq 0x56de(%rip), %rdi      # 0xd189
callq 0x7d21
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: read_type_suffix
static Type *read_type_suffix(Type *base) {
  if (!match("[")) {
    return base;
  }
  size_t size = expect(TINT, "integer")->integer;
  if (!match("]")) {
    parse_error("]", peek(0));
  }
  base = read_type_suffix(base);
  return array_of(base, size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5521(%rip), %rdi      # 0xd270
callq 0x7967
testq %rax, %rax
je 0x7d96
leaq 0x5512(%rip), %rsi      # 0xd272
xorl %edi, %edi
callq 0x8160
movslq 0xc(%rax), %r14
leaq 0x50fc(%rip), %rdi      # 0xce6e
callq 0x7967
testq %rax, %rax
je 0x7da1
movq %rbx, %rdi
callq 0x7d41
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x76b7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xa3b0(%rip), %rsi      # 0x12158
leaq 0x50bf(%rip), %rdi      # 0xce6e
callq 0x7d21
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: find_type
static Type *find_type(char *name) {
  for (TypeDef *td = typedefs; td != NULL; td = td->next) {
    if (streq(name, td->name)) {
      return td->type;
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xa111(%rip), %r15      # 0x12168
xorl %ebx, %ebx
movq (%r15), %r15
testq %r15, %r15
je 0x8075
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xaa3e
testl %eax, %eax
je 0x8059
movq 0x10(%r15), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: read_field
static Field *read_field() {
  match(";");
  if (match("}")) {
    return NULL;
  }

  Node *def = declarator(type_specifier());
  Field *field = calloc(1, sizeof(Field));
  field->name = def->name;
  field->type = def->type;
  field->next = read_field();
  return field;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x52c0(%rip), %rdi      # 0xd349
callq 0x7967
leaq 0x50f4(%rip), %rdi      # 0xd189
callq 0x7967
testq %rax, %rax
je 0x80a3
xorl %ebx, %ebx
jmp 0x80d9
callq 0x7db4
movq %rax, %rdi
callq 0x80e4
movq %rax, %r14
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x20f0
movq %rax, %rbx
movq 0x40(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
callq 0x807e
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: new_int_node
static Node *new_int_node(Token *token, int i) {
  Node *node = new_node(NINT, token);
  node->integer = i;
  node->type = int_type();
  return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %rsi
xorl %edi, %edi
callq 0x75dc
movq %rax, %r14
movl %ebx, 0x28(%rax)
callq 0x768c
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: add_gvar
static void add_gvar(Token *tok, char *name, Type *type, Node *init,
                     Vector *inits) {
  GVar *gvar = calloc(sizeof(GVar), 1);
  gvar->name = name;
  gvar->type = type;
  gvar->init = init;
  gvar->inits = inits;
  gvar->next = global_env;
  global_env = gvar;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x30
popq %rdi
pushq $0x1
popq %rsi
callq 0x20f0
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq 0x9f7d(%rip), %rcx      # 0x12160
movq %rcx, (%rax)
movq %rax, 0x9f73(%rip)      # 0x12160
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: assign
static Node *assign() {
  Node *node = logical_or();
  Token *token;

  if ((token = match("="))) {
    node = new_assign_node(token, 0, node, assign());
  } else if ((token = match("+="))) {
    node = new_assign_node(token, NADD, node, assign());
  } else if ((token = match("-="))) {
    node = new_assign_node(token, NSUB, node, assign());
  } else if ((token = match("*="))) {
    node = new_assign_node(token, NMUL, node, assign());
  }

  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x82f2
movq %rax, %rbx
leaq 0x5090(%rip), %rdi      # 0xd29d
callq 0x7967
testq %rax, %rax
je 0x8241
movq %rax, %r14
callq 0x81f9
movq %rax, %r15
pushq $0x17
popq %rdi
movq %r14, %rsi
callq 0x75dc
movq %rbx, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5040(%rip), %rdi      # 0xd288
callq 0x7967
testq %rax, %rax
je 0x825e
movq %rax, %r14
callq 0x81f9
pushq $0x3
jmp 0x8296
leaq 0x5026(%rip), %rdi      # 0xd28b
callq 0x7967
testq %rax, %rax
je 0x827b
movq %rax, %r14
callq 0x81f9
pushq $0x4
jmp 0x8296
leaq 0x500c(%rip), %rdi      # 0xd28e
callq 0x7967
testq %rax, %rax
je 0x8238
movq %rax, %r14
callq 0x81f9
pushq $0x5
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x82a7
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: new_assign_node
static Node *new_assign_node(Token *token, enum NodeTag op, Node *lhs,
                             Node *rhs) {
  Node *node = new_node(NASSIGN, token);
  node->lhs = lhs;
  if (op) {
    node->rhs = new_node(op, token);
    node->rhs->lhs = lhs;
    node->rhs->rhs = rhs;
    return node;
  }
  node->rhs = rhs;
  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
pushq $0x17
popq %rdi
movq %r12, %rsi
callq 0x75dc
movq %rax, %r15
movq %r14, 0x18(%rax)
testl %ebp, %ebp
je 0x82e2
movl %ebp, %edi
movq %r12, %rsi
callq 0x75dc
movq %rax, 0x20(%r15)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: logical_or
static Node *logical_or() {
  Node *lhs = logical_and();
  Token *tok;
  for (;;) {
    if ((tok = match("||"))) {
      Node *node = new_node(NLOGOR, tok);
      node->lhs = lhs;
      node->rhs = logical_and();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x8345
movq %rax, %r14
leaq 0x4f89(%rip), %rbx      # 0xd291
pushq $0x14
popq %rbp
movq %rbx, %rdi
callq 0x7967
testq %rax, %rax
je 0x8337
movl %ebp, %edi
movq %rax, %rsi
callq 0x75dc
movq %rax, %r15
movq %r14, 0x18(%rax)
callq 0x8345
movq %rax, 0x20(%r15)
movq %r15, %r14
jmp 0x830b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: logical_and
static Node *logical_and() {
  Node *lhs = bit_or();
  Token *tok;
  for (;;) {
    if ((tok = match("&&"))) {
      Node *node = new_node(NLOGAND, tok);
      node->lhs = lhs;
      node->rhs = bit_or();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x8398
movq %rax, %r14
leaq 0x4f39(%rip), %rbx      # 0xd294
pushq $0x13
popq %rbp
movq %rbx, %rdi
callq 0x7967
testq %rax, %rax
je 0x838a
movl %ebp, %edi
movq %rax, %rsi
callq 0x75dc
movq %rax, %r15
movq %r14, 0x18(%rax)
callq 0x8398
movq %rax, 0x20(%r15)
movq %r15, %r14
jmp 0x835e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: bit_or
static Node *bit_or() {
  Node *lhs = bit_xor();
  Token *token;
  for (;;) {
    if ((token = match("|"))) {
      Node *node = new_node(NOR, token);
      node->lhs = lhs;
      node->rhs = bit_xor();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x83eb
movq %rax, %r14
leaq 0x4ee4(%rip), %rbx      # 0xd292
pushq $0x11
popq %rbp
movq %rbx, %rdi
callq 0x7967
testq %rax, %rax
je 0x83dd
movl %ebp, %edi
movq %rax, %rsi
callq 0x75dc
movq %rax, %r15
movq %r14, 0x18(%rax)
callq 0x83eb
movq %rax, 0x20(%r15)
movq %r15, %r14
jmp 0x83b1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: bit_xor
static Node *bit_xor() {
  Node *lhs = bit_and();
  Token *token;
  for (;;) {
    if ((token = match("^"))) {
      Node *node = new_node(NXOR, token);
      node->lhs = lhs;
      node->rhs = bit_and();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x843e
movq %rax, %r14
leaq 0x4e96(%rip), %rbx      # 0xd297
pushq $0x12
popq %rbp
movq %rbx, %rdi
callq 0x7967
testq %rax, %rax
je 0x8430
movl %ebp, %edi
movq %rax, %rsi
callq 0x75dc
movq %rax, %r15
movq %r14, 0x18(%rax)
callq 0x843e
movq %rax, 0x20(%r15)
movq %r15, %r14
jmp 0x8404
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: bit_and
static Node *bit_and() {
  Node *lhs = equality();
  Token *token;
  for (;;) {
    if ((token = match("&"))) {
      Node *node = new_node(NAND, token);
      node->lhs = lhs;
      node->rhs = equality();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x8491
movq %rax, %r14
leaq 0x4e41(%rip), %rbx      # 0xd295
pushq $0x10
popq %rbp
movq %rbx, %rdi
callq 0x7967
testq %rax, %rax
je 0x8483
movl %ebp, %edi
movq %rax, %rsi
callq 0x75dc
movq %rax, %r15
movq %r14, 0x18(%rax)
callq 0x8491
movq %rax, 0x20(%r15)
movq %r15, %r14
jmp 0x8457
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: equality
static Node *equality() {
  Node *lhs = relational();
  Token *tok;
  for (;;) {
    if ((tok = match("=="))) {
      Node *node = new_node(NEQ, tok);
      node->lhs = lhs;
      node->rhs = relational();
      lhs = node;
    } else if ((tok = match("!="))) {
      Node *node = new_node(NNE, tok);
      node->lhs = lhs;
      node->rhs = relational();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x8509
movq %rax, %r15
leaq 0x4dee(%rip), %rbx      # 0xd299
leaq 0x4dea(%rip), %r14      # 0xd29c
pushq $0xd
popq %rbp
pushq $0xc
popq %r12
movq %rbx, %rdi
callq 0x7967
testq %rax, %rax
je 0x84cb
movl %r12d, %edi
jmp 0x84da
movq %r14, %rdi
callq 0x7967
testq %rax, %rax
je 0x84f7
movl %ebp, %edi
movq %rax, %rsi
callq 0x75dc
movq %rax, %r13
movq %r15, 0x18(%rax)
callq 0x8509
movq %rax, 0x20(%r13)
movq %r13, %r15
jmp 0x84b9
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: relational
static Node *relational() {
  Node *lhs = add();
  Token *tok;
  for (;;) {
    if ((tok = match("<"))) {
      Node *node = new_node(NLT, tok);
      node->lhs = lhs;
      node->rhs = add();
      lhs = node;
    } else if ((tok = match("<="))) {
      Node *node = new_node(NLE, tok);
      node->lhs = lhs;
      node->rhs = add();
      lhs = node;
    } else if ((tok = match(">"))) {
      Node *node = new_node(NGT, tok);
      node->lhs = lhs;
      node->rhs = add();
      lhs = node;
    } else if ((tok = match(">="))) {
      Node *node = new_node(NGE, tok);
      node->lhs = lhs;
      node->rhs = add();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x85ad
movq %rax, %r15
leaq 0x504a(%rip), %rbx      # 0xd56d
leaq 0x503b(%rip), %r14      # 0xd565
pushq $0x9
popq %r13
pushq $0x8
popq %rbp
movq %rbx, %rdi
callq 0x7967
testq %rax, %rax
je 0x8542
movl %ebp, %edi
jmp 0x857d
movq %r14, %rdi
callq 0x7967
testq %rax, %rax
je 0x8554
movl %r13d, %edi
jmp 0x857d
leaq 0x4d52(%rip), %rdi      # 0xd2ad
callq 0x7967
testq %rax, %rax
je 0x8569
pushq $0xa
jmp 0x857c
leaq 0x4ff9(%rip), %rdi      # 0xd569
callq 0x7967
testq %rax, %rax
je 0x859b
pushq $0xb
popq %rdi
movq %rax, %rsi
callq 0x75dc
movq %rax, %r12
movq %r15, 0x18(%rax)
callq 0x85ad
movq %rax, 0x20(%r12)
movq %r12, %r15
jmp 0x8531
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: add
static Node *add() {
  Node *lhs = mul();
  Token *tok;
  for (;;) {
    if ((tok = match("+"))) {
      Node *node = new_node(NADD, tok);
      node->lhs = lhs;
      node->rhs = mul();
      lhs = node;
    } else if ((tok = match("-"))) {
      Node *node = new_node(NSUB, tok);
      node->lhs = lhs;
      node->rhs = mul();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x8625
movq %rax, %r15
leaq 0x4ce9(%rip), %rbx      # 0xd2b0
leaq 0x4ce5(%rip), %r14      # 0xd2b3
pushq $0x4
popq %rbp
pushq $0x3
popq %r12
movq %rbx, %rdi
callq 0x7967
testq %rax, %rax
je 0x85e7
movl %r12d, %edi
jmp 0x85f6
movq %r14, %rdi
callq 0x7967
testq %rax, %rax
je 0x8613
movl %ebp, %edi
movq %rax, %rsi
callq 0x75dc
movq %rax, %r13
movq %r15, 0x18(%rax)
callq 0x8625
movq %rax, 0x20(%r13)
movq %r13, %r15
jmp 0x85d5
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: mul
static Node *mul() {
  Node *lhs = cast();
  Token *tok;
  for (;;) {
    if ((tok = match("*"))) {
      Node *node = new_node(NMUL, tok);
      node->lhs = lhs;
      node->rhs = cast();
      lhs = node;
    } else if ((tok = match("/"))) {
      Node *node = new_node(NDIV, tok);
      node->lhs = lhs;
      node->rhs = cast();
      lhs = node;
    } else if ((tok = match("%"))) {
      Node *node = new_node(NMOD, tok);
      node->lhs = lhs;
      node->rhs = cast();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x86b4
movq %rax, %r15
leaq 0x4e90(%rip), %rbx      # 0xd4cf
leaq 0x4e8c(%rip), %r14      # 0xd4d2
pushq $0x6
popq %r13
pushq $0x5
popq %rbp
movq %rbx, %rdi
callq 0x7967
testq %rax, %rax
je 0x865e
movl %ebp, %edi
jmp 0x8684
movq %r14, %rdi
callq 0x7967
testq %rax, %rax
je 0x8670
movl %r13d, %edi
jmp 0x8684
leaq 0x4c28(%rip), %rdi      # 0xd29f
callq 0x7967
testq %rax, %rax
je 0x86a2
pushq $0x7
popq %rdi
movq %rax, %rsi
callq 0x75dc
movq %rax, %r12
movq %r15, 0x18(%rax)
callq 0x86b4
movq %rax, 0x20(%r12)
movq %r12, %r15
jmp 0x864d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: cast
static Node *cast() {
  if (eq_reserved(peek(0), "(") && is_typename(peek(1))) {
    Token *token = peek(0);
    consume();
    Type *type = type_specifier();
    while (match("*")) {
      type = ptr_to(type);
    }
    if (!match(")")) {
      parse_error(")", peek(0));
    }
    Node *node = new_node(NCAST, token);
    node->type = type;
    node->expr = cast();
    return node;
  } else {
    return unary();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x9a98(%rip), %rdi      # 0x12158
leaq 0x518b(%rip), %rsi      # 0xd852
callq 0xab1d
testb %al, %al
je 0x871d
movq 0x9a81(%rip), %rax      # 0x12158
movq (%rax), %rdi
callq 0x876f
testl %eax, %eax
je 0x871d
movq 0x9a6e(%rip), %rbx      # 0x12158
movq (%rbx), %rax
movq %rax, 0x9a64(%rip)      # 0x12158
callq 0x7db4
movq %rax, %r14
leaq 0x4dcc(%rip), %r15      # 0xd4cf
movq %r15, %rdi
callq 0x7967
testq %rax, %rax
je 0x8727
movq %r14, %rdi
callq 0x76a2
movq %rax, %r14
jmp 0x8703
popq %rbx
popq %r14
popq %r15
jmp 0x87d5
leaq 0x4bc4(%rip), %rdi      # 0xd2f2
callq 0x7967
testq %rax, %rax
je 0x875c
pushq $0x28
popq %rdi
movq %rbx, %rsi
callq 0x75dc
movq %rax, %rbx
movq %r14, 0x10(%rax)
callq 0x86b4
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x99f5(%rip), %rsi      # 0x12158
leaq 0x4b88(%rip), %rdi      # 0xd2f2
callq 0x7d21
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: is_typename
static int is_typename(Token *t) {
  if (eq_reserved(t, "struct")) {
    return 1;
  }

  if (eq_reserved(t, "enum")) {
    return 1;
  }

  if (t->tag == TIDENT || t->tag == TRESERVED) {
    for (TypeDef *td = typedefs; td != NULL; td = td->next) {
      if (streq(t->ident, td->name)) {
        return 1;
      }
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x4abd(%rip), %rsi      # 0xd23b
callq 0xab1d
pushq $0x1
popq %rbx
testb %al, %al
jne 0x87cd
leaq 0x4ada(%rip), %rsi      # 0xd26b
movq %r14, %rdi
callq 0xab1d
testb %al, %al
jne 0x87cd
movl 0x8(%r14), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x87cb
leaq 0x99b8(%rip), %r15      # 0x12168
movq (%r15), %r15
testq %r15, %r15
je 0x87cb
movq 0x10(%r14), %rdi
movq 0x8(%r15), %rsi
callq 0xaa3e
testl %eax, %eax
je 0x87b0
jmp 0x87cd
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: new_subscript
static Node *new_subscript(Token *token, Node *value, Node *index) {
  Node *node = new_node(NDEREF, token);
  node->expr = new_node(NADD, token);
  node->expr->lhs = value;
  node->expr->rhs = index;
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1a
popq %rdi
movq %r15, %rsi
callq 0x75dc
movq %rax, %r12
pushq $0x3
popq %rdi
movq %r15, %rsi
callq 0x75dc
movq %rax, 0x38(%r12)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: find_var
static Node *find_var(Token *tok, char *name) {
  for (LVar *env = local_env; env != NULL; env = env->next) {
    if (streq(name, env->name)) {
      return new_var(tok, env->name, env->type, env->offset);
    }
  }

  for (GVar *env = global_env; env != NULL; env = env->next) {
    if (streq(name, env->name)) {
      return new_gvar(tok, env->name, env->type);
    }
  }

  for (Enum *env = enum_env; env != NULL; env = env->next) {
    if (streq(name, env->name)) {
      Node *val = clone_node(env->val);
      val->token = tok;
      return val;
    }
  }

  bad_token(tok, format("%s is not defined\n", name));
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x93d8(%rip), %r15      # 0x12180
movq (%r15), %r15
testq %r15, %r15
je 0x8de5
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xaa3e
testl %eax, %eax
je 0x8da8
movq 0x8(%r15), %r14
movq 0x10(%r15), %r12
movslq 0x18(%r15), %r15
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq 0x75dc
movq %r14, 0x40(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x48(%rax)
jmp 0x8e4d
leaq 0x9374(%rip), %r15      # 0x12160
movq (%r15), %r15
testq %r15, %r15
je 0x8e21
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xaa3e
testl %eax, %eax
je 0x8dec
movq 0x8(%r15), %r14
movq 0x10(%r15), %r15
pushq $0x2
popq %rdi
movq %rbx, %rsi
callq 0x75dc
movq %r14, 0x40(%rax)
movq %r15, 0x10(%rax)
jmp 0x8e4d
leaq 0x9350(%rip), %r15      # 0x12178
movq (%r15), %r15
testq %r15, %r15
je 0x8e59
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xaa3e
testl %eax, %eax
je 0x8e28
movq 0x10(%r15), %rdi
callq 0x7656
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4455(%rip), %rdi      # 0xd2b5
movq %r14, %rsi
xorl %eax, %eax
callq 0xa84a
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa124
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: comma
static Node *comma() {
  Node *lhs = assign();

  Token *tok;
  for (;;) {
    if ((tok = match(","))) {
      Node *node = new_node(NCOMMA, tok);
      node->lhs = lhs;
      node->rhs = assign();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x81f9
movq %rax, %r14
leaq 0x31c3(%rip), %rbx      # 0xc04e
pushq $0x15
popq %rbp
movq %rbx, %rdi
callq 0x7967
testq %rax, %rax
je 0x8eba
movl %ebp, %edi
movq %rax, %rsi
callq 0x75dc
movq %rax, %r15
movq %r14, 0x18(%rax)
callq 0x81f9
movq %rax, 0x20(%r15)
movq %r15, %r14
jmp 0x8e8e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: add_lvar
static void add_lvar(Token *tok, char *name, Type *ty) {
  local_size += size_of(ty);
  LVar *lvar = calloc(sizeof(LVar), 1);
  lvar->name = name;
  lvar->type = ty;
  lvar->offset = local_size;
  lvar->next = local_env;
  local_env = lvar;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x75fe
movq %rax, %r15
addq 0x92ab(%rip), %r15      # 0x12190
movq %r15, 0x92a4(%rip)      # 0x12190
pushq $0x20
popq %rdi
pushq $0x1
popq %rsi
callq 0x20f0
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movl %r15d, 0x18(%rax)
movq 0x9276(%rip), %rcx      # 0x12180
movq %rcx, (%rax)
movq %rax, 0x926c(%rip)      # 0x12180
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: declaration
static Node *declaration() {
  // variable definition
  Node *decl = declarator(type_specifier());
  add_lvar(decl->token, decl->name, decl->type);

  Token *tok;
  if ((tok = match("="))) {
    Node *comma = new_node(NCOMMA, tok);
    comma->lhs = decl;
    comma->rhs = read_initializer(tok, find_var(tok, decl->name));
    return comma;
  }

  return decl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x7db4
movq %rax, %rdi
callq 0x80e4
movq %rax, %r15
movq 0x10(%rax), %rsi
movq 0x40(%rax), %rdi
callq 0x8ec8
leaq 0x3e1a(%rip), %rdi      # 0xd29d
callq 0x7967
testq %rax, %rax
je 0x951f
movq %rax, %r14
pushq $0x15
popq %rdi
movq %rax, %rsi
callq 0x75dc
movq %rax, %rbx
movq %r15, 0x18(%rax)
movq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x8d93
movq %rax, %r15
leaq 0x3d8f(%rip), %rdi      # 0xd24b
callq 0x7967
testq %rax, %rax
je 0x94fa
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x952e
movq %rax, %r14
leaq 0x3cac(%rip), %rdi      # 0xd189
callq 0x7967
testq %rax, %rax
jne 0x9518
movq 0x8c6a(%rip), %rsi      # 0x12158
leaq 0x3c94(%rip), %rdi      # 0xd189
callq 0x7d21
callq 0x81f9
movq %rax, %r12
pushq $0x17
popq %rdi
movq %r14, %rsi
callq 0x75dc
movq %rax, %r14
movq %r15, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %r14, 0x20(%rbx)
movq %rbx, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/parse.c
// Function: read_init_list
static Node *read_init_list(Token *token, Node *var, int i) {
  Node *node = new_assign_node(
      token, 0, new_subscript(token, var, new_int_node(token, i)), assign());
  if (eq_reserved(peek(0), "}")) {
    Node *comma = new_node(NCOMMA, token);
    comma->lhs = node;
    comma->rhs = var;
    return comma;
  }
  if (!match(",")) {
    parse_error(",", peek(0));
  }
  Node *comma = new_node(NCOMMA, token);
  comma->lhs = node;
  comma->rhs = read_init_list(token, var, i + 1);
  return comma;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
callq 0x8183
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x8d4d
movq %rax, %r12
callq 0x81f9
movq %rax, %r13
pushq $0x17
popq %rdi
movq %r14, %rsi
callq 0x75dc
movq %rax, %r15
movq %r12, 0x18(%rax)
movq %r13, 0x20(%rax)
movq 0x8bda(%rip), %rdi      # 0x12158
leaq 0x3c04(%rip), %rsi      # 0xd189
callq 0xab1d
testb %al, %al
je 0x95a2
pushq $0x15
popq %rdi
movq %r14, %rsi
callq 0x75dc
movq %rax, %r12
movq %r15, 0x18(%rax)
jmp 0x95d7
leaq 0x2aa5(%rip), %rdi      # 0xc04e
callq 0x7967
testq %rax, %rax
je 0x95ee
pushq $0x15
popq %rdi
movq %r14, %rsi
callq 0x75dc
movq %rax, %r12
movq %r15, 0x18(%rax)
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x952e
movq %rax, %rbx
movq %rbx, 0x20(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8b63(%rip), %rsi      # 0x12158
leaq 0x2a52(%rip), %rdi      # 0xc04e
callq 0x7d21
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/regalloc.c
// Function: scan
void scan(Vector* regs) {
  IReg** used = calloc(NUM_REGS, sizeof(IReg*));

  for (int i = 0; i < regs->length; i++) {
    IReg* reg = regs->ptr[i];
    bool found = false;

    for (int i = 0; i < NUM_REGS - 1; i++) {
      if (!(used[i] && reg->def < used[i]->last_use)) {
        assert(i < NUM_REGS);
        reg->real_reg = i;
        used[i] = reg;
        found = true;
        break;
      }
    }

    if (!found) {
      used[NUM_REGS - 1] = reg;
      int k = choose_to_spill(used);
      reg->real_reg = k;
      used[k]->real_reg = NUM_REGS - 1;
      used[k]->spill = true;
      used[k] = reg;
      error("error: register allocation %s\n", show_ireg(reg));
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x7
popq %rdi
pushq $0x8
popq %rsi
callq 0x20f0
movq %rax, %rbx
movq 0x10(%r14), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
je 0x9657
movq (%r14), %rdx
movq (%rdx,%rcx,8), %r15
xorl %edx, %edx
cmpq $0x6, %rdx
je 0x965d
movq (%rbx,%rdx,8), %rsi
testq %rsi, %rsi
je 0x964b
movl 0x10(%r15), %edi
cmpl 0x14(%rsi), %edi
jge 0x964b
incq %rdx
jmp 0x962e
movl %edx, (%r15)
movq %r15, (%rbx,%rdx,8)
incq %rcx
jmp 0x9620
popq %rbx
popq %r14
popq %r15
retq
movq %r15, 0x30(%rbx)
movq %rbx, %rdi
callq 0x9695
movl %eax, (%r15)
cltq
movq (%rbx,%rax,8), %rax
movl $0x6, (%rax)
movb $0x1, 0x18(%rax)
movq %r15, %rdi
callq 0x6cbf
leaq 0x3ce1(%rip), %rdi      # 0xd36c
movq %rax, %rsi
xorl %eax, %eax
callq 0xa90e
// File: /workspace/github_c_makefile_star2_O2/takoeight0821[P]hoc_nyan/src/regalloc.c
// Function: choose_to_spill
static int choose_to_spill(IReg **used) {
  int k = 0;
  for (int i = 1; i < NUM_REGS; i++) {
    if (used[k]->last_use < used[i]->last_use) {
      k = i;
    }
  }
  return k;

}

// Assembly:
xorl %eax, %eax
pushq $0x1
popq %rcx
cmpq $0x7, %rcx
je 0x96bf
movslq %eax, %rdx
movq (%rdi,%rdx,8), %rdx
movl 0x14(%rdx), %esi
movq (%rdi,%rcx,8), %r8
movl %ecx, %edx
cmpl 0x14(%r8), %esi
jl 0x96b8
movl %eax, %edx
incq %rcx
movl %edx, %eax
jmp 0x969a
retq