LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x8b10
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
cmpl $0x2, %eax
je 0x8b18
testl %eax, %eax
jne 0x8baf
movq %r14, %rdi
callq 0x9c8c
cmpq $0x1, %rax
jne 0x8b4e
movl 0x28(%rbx), %esi
leaq 0x62da(%rip), %rdi      # 0xede5
jmp 0x8ba4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x9c8c
cmpq $0x1, %rax
jne 0x8b33
movq 0x40(%rbx), %rsi
leaq 0x62c6(%rip), %rdi      # 0xedf7
jmp 0x8b81
movq %r14, %rdi
callq 0x9c8c
cmpq $0x4, %rax
jne 0x8b68
movq 0x40(%rbx), %rsi
leaq 0x62b1(%rip), %rdi      # 0xedfd
jmp 0x8b81
movq %r14, %rdi
callq 0x9c8c
cmpq $0x4, %rax
jne 0x8b8c
movl 0x28(%rbx), %esi
leaq 0x6285(%rip), %rdi      # 0xedeb
jmp 0x8ba4
movq %r14, %rdi
callq 0x9c8c
cmpq $0x8, %rax
jne 0x8bbf
movq 0x40(%rbx), %rsi
leaq 0x6282(%rip), %rdi      # 0xee03
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8bcf
movq %r14, %rdi
callq 0x9c8c
cmpq $0x8, %rax
jne 0x8bbf
movl 0x28(%rbx), %esi
leaq 0x624d(%rip), %rdi      # 0xedf1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8bcf
movq 0x8(%rbx), %rdi
leaq 0x560d(%rip), %rsi      # 0xe1c7
callq 0xce4d
movq 0x8(%rbx), %rdi
leaq 0x55be(%rip), %rsi      # 0xe188
callq 0xce4d
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl $0x1, %edi
movl $0x58, %esi
callq 0x20f0
movl %ebp, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x8d4a
movq (%rax), %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rdx,%rsi,8), %rdi
movq 0x8(%rdi), %r8
movq 0x10(%r8), %rdi
testq %rdi, %rdi
je 0x8d41
movq (%r8), %r8
xorl %r9d, %r9d
movq (%r8,%r9,8), %r10
cmpl $0x12, (%r10)
jne 0x8d39
addl 0x4(%r10), %eax
incq %r9
cmpq %r9, %rdi
jne 0x8d2b
incq %rsi
cmpq %rcx, %rsi
jne 0x8d14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd963
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x5936(%rip), %rdi      # 0xf17b
xorl %eax, %eax
callq 0xd7f2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd9e1
movq 0x8(%r14), %rax
cmpq $0x0, 0x10(%rax)
je 0x98c0
leaq 0x5919(%rip), %r12      # 0xf182
leaq 0x5c50(%rip), %r13      # 0xf4c0
xorl %ebp, %ebp
movl (%r15), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0xd7f2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd9e1
movq 0x8(%r14), %rax
movq (%rax), %rax
movq (%rax,%rbp,8), %rdi
callq 0x8d6c
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd9e1
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd9e1
incl (%r15)
incq %rbp
movq 0x8(%r14), %rax
cmpq %rbp, 0x10(%rax)
ja 0x9872
leaq 0x58c2(%rip), %rsi      # 0xf189
movq %rbx, %rdi
callq 0xd9e1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xda17
// File: /workspace/github_c_makefile_star2_O1/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 0x9a10
callq 0xd963
movq %rax, %r14
movl $0x0, 0xc(%rsp)
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x5877(%rip), %rdi      # 0xf195
xorl %eax, %eax
callq 0xd7f2
movq %r14, %rdi
movq %rax, %rsi
callq 0xd9e1
leaq 0x586e(%rip), %rsi      # 0xf1a5
movq %r14, %rdi
callq 0xd9e1
movq 0x10(%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x99a0
leaq 0x56b7(%rip), %r15      # 0xf008
leaq 0x48f5(%rip), %r12      # 0xe24d
xorl %r13d, %r13d
movq (%rax), %rax
movq (%rax,%r13,8), %rax
movl (%rax), %ecx
movl 0x4(%rax), %esi
movq 0x8(%rax), %rdx
movl 0x10(%rax), %r8d
movl 0x14(%rax), %r9d
movq %r15, %rdi
xorl %eax, %eax
callq 0xd7f2
movq %r14, %rdi
movq %rax, %rsi
callq 0xd9e1
movq %r14, %rdi
movq %r12, %rsi
callq 0xd9e1
incq %r13
movq 0x10(%rbx), %rax
cmpq %r13, 0x10(%rax)
ja 0x995b
leaq 0x5b19(%rip), %rsi      # 0xf4c0
movq %r14, %rdi
callq 0xd9e1
movq 0x18(%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x99fb
xorl %r13d, %r13d
leaq 0xc(%rsp), %r15
leaq 0x5af7(%rip), %r12      # 0xf4c0
movq (%rax), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
callq 0x9822
movq %r14, %rdi
movq %rax, %rsi
callq 0xd9e1
movq %r14, %rdi
movq %r12, %rsi
callq 0xd9e1
incq %r13
movq 0x18(%rbx), %rax
cmpq %r13, 0x10(%rax)
ja 0x99c9
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xda17
movq (%rbx), %rsi
leaq 0x5771(%rip), %rdi      # 0xf18b
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd7f2
// File: /workspace/github_c_makefile_star2_O1/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
callq 0xd963
movq %rax, %r14
movq (%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x9a6e
xorl %r15d, %r15d
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
callq 0x98e5
movq %r14, %rdi
movq %rax, %rsi
callq 0xd9e1
incq %r15
movq (%rbx), %rax
cmpq %r15, 0x10(%rax)
ja 0x9a4b
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xda17
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
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_O1/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
movl $0x1, %edi
movl $0x38, %esi
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_O1/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
movl $0x1, %edi
movl $0x38, %esi
callq 0x20f0
movl $0x4, (%rax)
movl $0x8, %ecx
movq %rcx, 0x10(%rax)
movq %rcx, 0x8(%rax)
movq %r14, 0x18(%rax)
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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %bpl
je 0x9ec8
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xd952
movq %r14, %r15
testl %eax, %eax
jne 0x9e64
movq %r14, %r15
movq (%r15), %r15
testq %r15, %r15
sete %bpl
je 0x9ec8
movq 0x8(%r15), %rdi
movq %rbx, %rsi
callq 0xd952
testl %eax, %eax
je 0x9e48
testb %bpl, %bpl
jne 0x9ec8
jmp 0x9ed0
movq 0x10(%r14), %rax
movq 0x30(%rax), %rdi
testq %rdi, %rdi
je 0x9ec5
movq %rbx, %rsi
callq 0x9e14
movq %rax, %r12
testq %rax, %rax
je 0x9ec0
movl $0x1, %edi
movl $0x20, %esi
callq 0x20f0
movq %rax, %r15
movq 0x8(%r12), %rax
movq %rax, 0x8(%r15)
movq 0x10(%r12), %rax
movq %rax, 0x10(%r15)
movq (%r12), %rax
movq %rax, (%r15)
movq 0x18(%r12), %rax
addq 0x18(%r14), %rax
movq %rax, 0x18(%r15)
testq %r12, %r12
jne 0x9ed0
movq (%r14), %r14
testq %r14, %r14
jne 0x9e6b
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9e14
testq %rax, %rax
je 0x9eed
movq 0x10(%rax), %rax
popq %rcx
retq
leaq 0x52d8(%rip), %rdi      # 0xf1cc
xorl %eax, %eax
callq 0xd8b8
// File: /workspace/github_c_makefile_star2_O1/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 0x9e14
testq %rax, %rax
je 0x9f0c
movq 0x18(%rax), %rax
popq %rcx
retq
leaq 0x52d1(%rip), %rdi      # 0xf1e4
xorl %eax, %eax
callq 0xd8b8
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x8fcc(%rip), %rax      # 0x13158
cmpl $0x3, 0x8(%rax)
jne 0xa1b5
movq %rdi, %rsi
movq 0x10(%rax), %rdi
callq 0xd952
testl %eax, %eax
je 0xa1b5
movq 0x8faf(%rip), %rax      # 0x13158
movq (%rax), %rcx
movq %rcx, 0x8fa5(%rip)      # 0x13158
jmp 0xa1b7
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa6d2
movq %rax, %rbx
leaq 0x52ff(%rip), %rdi      # 0xf4cf
callq 0xa184
testq %rax, %rax
je 0xa1f9
leaq 0x52ee(%rip), %r14      # 0xf4cf
movq %rbx, %rdi
callq 0x9d9e
movq %rax, %rbx
movq %r14, %rdi
callq 0xa184
testq %rax, %rax
jne 0xa1e1
leaq 0x5027(%rip), %rsi      # 0xf227
movl $0x2, %edi
callq 0xaaee
movq 0x10(%rax), %r12
movq %rbx, %rdi
callq 0xa64b
movq %rax, %rbx
leaq 0x507d(%rip), %rdi      # 0xf29d
callq 0xa184
testq %rax, %rax
je 0xa2cc
leaq 0x5016(%rip), %rdi      # 0xf24b
callq 0xa184
testq %rax, %rax
je 0xa2ec
xorl %eax, %eax
callq 0x307c
movq %rax, %r14
callq 0xab23
movq %r14, %rdi
movq %rax, %rsi
callq 0x30b6
leaq 0x3dea(%rip), %rdi      # 0xe04e
callq 0xa184
testq %rax, %rax
je 0xa292
leaq 0x3dd9(%rip), %r15      # 0xe04e
callq 0xab23
movq %r14, %rdi
movq %rax, %rsi
callq 0x30b6
movq %r15, %rdi
callq 0xa184
testq %rax, %rax
jne 0xa275
leaq 0x4ef0(%rip), %rdi      # 0xf189
callq 0xa184
testq %rax, %rax
je 0xa35c
movl $0x30, %edi
movl $0x1, %esi
callq 0x20f0
movq %r12, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %r14, 0x20(%rax)
jmp 0xa317
movl $0x30, %edi
movl $0x1, %esi
callq 0x20f0
movq %r12, 0x8(%rax)
movq %rbx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
jmp 0xa317
callq 0xb9e6
movq %rax, %r14
movl $0x30, %edi
movl $0x1, %esi
callq 0x20f0
movq %r12, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r14, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq 0x8e42(%rip), %rcx      # 0x13160
movq %rcx, (%rax)
movq %rax, 0x8e38(%rip)      # 0x13160
leaq 0x501a(%rip), %rdi      # 0xf349
callq 0xa184
testq %rax, %rax
je 0xa345
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8e0c(%rip), %rbx      # 0x13158
leaq 0x3cfd(%rip), %rdi      # 0xe050
leaq 0x4f20(%rip), %rsi      # 0xf27a
jmp 0xa371
movq 0x8df5(%rip), %rbx      # 0x13158
leaq 0x3ce6(%rip), %rdi      # 0xe050
leaq 0x4e18(%rip), %rsi      # 0xf189
xorl %eax, %eax
callq 0xd7f2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xce4d
// File: /workspace/github_c_makefile_star2_O1/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 0x4c17(%rip), %rdi      # 0xf270
callq 0xa184
testq %rax, %rax
je 0xa6a0
leaq 0x4c08(%rip), %rsi      # 0xf272
xorl %edi, %edi
callq 0xaaee
movslq 0xc(%rax), %r14
leaq 0x47f2(%rip), %rdi      # 0xee6e
callq 0xa184
testq %rax, %rax
je 0xa6ab
movq %rbx, %rdi
callq 0xa64b
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9dca
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8aa6(%rip), %rbx      # 0x13158
leaq 0x3997(%rip), %rdi      # 0xe050
leaq 0x47ae(%rip), %rsi      # 0xee6e
xorl %eax, %eax
callq 0xd7f2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xce4d
// File: /workspace/github_c_makefile_star2_O1/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 0x495f(%rip), %rdi      # 0xf349
callq 0xa184
leaq 0x4793(%rip), %rdi      # 0xf189
callq 0xa184
testq %rax, %rax
je 0xaa04
xorl %ebx, %ebx
jmp 0xaa3e
callq 0xa6d2
movq %rax, %rdi
callq 0xaa49
movq %rax, %r14
movl $0x1, %edi
movl $0x20, %esi
callq 0x20f0
movq %rax, %rbx
movq 0x40(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
callq 0xa9df
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/parse.c
// Function: expect
static Token *expect(enum TokenTag tag, char *expected) {
  if (peek_tag(0) == tag) {
    Token *t = tokens;
    consume();
    return t;
  }
  parse_error(expected, peek(0));
  return NULL;
}

// Assembly:
pushq %rbx
movq 0x8662(%rip), %rbx      # 0x13158
cmpl %edi, 0x8(%rbx)
jne 0xab0a
movq (%rbx), %rax
movq %rax, 0x8653(%rip)      # 0x13158
movq %rbx, %rax
popq %rbx
retq
leaq 0x353f(%rip), %rdi      # 0xe050
xorl %eax, %eax
callq 0xd7f2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xce4d
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
callq 0xac2d
movq %rax, %rbx
leaq 0x4763(%rip), %rdi      # 0xf29d
callq 0xa184
testq %rax, %rax
je 0xab64
movq %rax, %r15
callq 0xab23
movq %rax, %r14
movl $0x17, %edi
movq %r15, %rsi
callq 0x9c68
movq %rax, %r15
jmp 0xac13
leaq 0x471d(%rip), %rdi      # 0xf288
callq 0xa184
testq %rax, %rax
je 0xab9b
movq %rax, %r12
callq 0xab23
movq %rax, %r14
movl $0x17, %edi
movq %r12, %rsi
callq 0x9c68
movq %rax, %r15
movq %rbx, 0x18(%rax)
movl $0x3, %edi
jmp 0xac07
leaq 0x46e9(%rip), %rdi      # 0xf28b
callq 0xa184
testq %rax, %rax
je 0xabd2
movq %rax, %r12
callq 0xab23
movq %rax, %r14
movl $0x17, %edi
movq %r12, %rsi
callq 0x9c68
movq %rax, %r15
movq %rbx, 0x18(%rax)
movl $0x4, %edi
jmp 0xac07
leaq 0x46b5(%rip), %rdi      # 0xf28e
callq 0xa184
testq %rax, %rax
je 0xac1e
movq %rax, %r12
callq 0xab23
movq %rax, %r14
movl $0x17, %edi
movq %r12, %rsi
callq 0x9c68
movq %rax, %r15
movq %rbx, 0x18(%rax)
movl $0x5, %edi
movq %r12, %rsi
callq 0x9c68
movq %rax, 0x20(%r15)
movq %rbx, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
callq 0xac8d
movq %rax, %rbx
leaq 0x4650(%rip), %rdi      # 0xf291
callq 0xa184
testq %rax, %rax
je 0xac81
leaq 0x463f(%rip), %r14      # 0xf291
movl $0x14, %edi
movq %rax, %rsi
callq 0x9c68
movq %rax, %r15
movq %rbx, 0x18(%rax)
callq 0xac8d
movq %rax, 0x20(%r15)
movq %r14, %rdi
callq 0xa184
movq %r15, %rbx
testq %rax, %rax
jne 0xac52
jmp 0xac84
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
callq 0xaced
movq %rax, %rbx
leaq 0x45f3(%rip), %rdi      # 0xf294
callq 0xa184
testq %rax, %rax
je 0xace1
leaq 0x45e2(%rip), %r14      # 0xf294
movl $0x13, %edi
movq %rax, %rsi
callq 0x9c68
movq %rax, %r15
movq %rbx, 0x18(%rax)
callq 0xaced
movq %rax, 0x20(%r15)
movq %r14, %rdi
callq 0xa184
movq %r15, %rbx
testq %rax, %rax
jne 0xacb2
jmp 0xace4
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
callq 0xad4d
movq %rax, %rbx
leaq 0x4591(%rip), %rdi      # 0xf292
callq 0xa184
testq %rax, %rax
je 0xad41
leaq 0x4580(%rip), %r14      # 0xf292
movl $0x11, %edi
movq %rax, %rsi
callq 0x9c68
movq %rax, %r15
movq %rbx, 0x18(%rax)
callq 0xad4d
movq %rax, 0x20(%r15)
movq %r14, %rdi
callq 0xa184
movq %r15, %rbx
testq %rax, %rax
jne 0xad12
jmp 0xad44
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
callq 0xadad
movq %rax, %rbx
leaq 0x4536(%rip), %rdi      # 0xf297
callq 0xa184
testq %rax, %rax
je 0xada1
leaq 0x4525(%rip), %r14      # 0xf297
movl $0x12, %edi
movq %rax, %rsi
callq 0x9c68
movq %rax, %r15
movq %rbx, 0x18(%rax)
callq 0xadad
movq %rax, 0x20(%r15)
movq %r14, %rdi
callq 0xa184
movq %r15, %rbx
testq %rax, %rax
jne 0xad72
jmp 0xada4
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
callq 0xae0d
movq %rax, %rbx
leaq 0x44d4(%rip), %rdi      # 0xf295
callq 0xa184
testq %rax, %rax
je 0xae01
leaq 0x44c3(%rip), %r14      # 0xf295
movl $0x10, %edi
movq %rax, %rsi
callq 0x9c68
movq %rax, %r15
movq %rbx, 0x18(%rax)
callq 0xae0d
movq %rax, 0x20(%r15)
movq %r14, %rdi
callq 0xa184
movq %r15, %rbx
testq %rax, %rax
jne 0xadd2
jmp 0xae04
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0xae7e
movq %rax, %r15
leaq 0x4475(%rip), %rbx      # 0xf299
leaq 0x4471(%rip), %r14      # 0xf29c
movq %rbx, %rdi
callq 0xa184
testq %rax, %rax
je 0xae3f
movl $0xc, %edi
jmp 0xae51
movq %r14, %rdi
callq 0xa184
testq %rax, %rax
je 0xae6f
movl $0xd, %edi
movq %rax, %rsi
callq 0x9c68
movq %rax, %r12
movq %r15, 0x18(%rax)
callq 0xae7e
movq %rax, 0x20(%r12)
movq %r12, %r15
jmp 0xae2b
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xaf2a
movq %rax, %r12
leaq 0x46d5(%rip), %rbx      # 0xf56d
leaq 0x46c6(%rip), %r14      # 0xf565
leaq 0x4407(%rip), %r15      # 0xf2ad
leaq 0x46bc(%rip), %r13      # 0xf569
movq %rbx, %rdi
callq 0xa184
testq %rax, %rax
je 0xaec1
movl $0x8, %edi
jmp 0xaefb
movq %r14, %rdi
callq 0xa184
testq %rax, %rax
je 0xaed5
movl $0x9, %edi
jmp 0xaefb
movq %r15, %rdi
callq 0xa184
testq %rax, %rax
je 0xaee9
movl $0xa, %edi
jmp 0xaefb
movq %r13, %rdi
callq 0xa184
testq %rax, %rax
je 0xaf18
movl $0xb, %edi
movq %rax, %rsi
callq 0x9c68
movq %rax, %rbp
movq %r12, 0x18(%rax)
callq 0xaf2a
movq %rax, 0x20(%rbp)
movq %rbp, %r12
jmp 0xaead
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0xaf9b
movq %rax, %r15
leaq 0x436f(%rip), %rbx      # 0xf2b0
leaq 0x436b(%rip), %r14      # 0xf2b3
movq %rbx, %rdi
callq 0xa184
testq %rax, %rax
je 0xaf5c
movl $0x3, %edi
jmp 0xaf6e
movq %r14, %rdi
callq 0xa184
testq %rax, %rax
je 0xaf8c
movl $0x4, %edi
movq %rax, %rsi
callq 0x9c68
movq %rax, %r12
movq %r15, 0x18(%rax)
callq 0xaf9b
movq %rax, 0x20(%r12)
movq %r12, %r15
jmp 0xaf48
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0xb025
movq %rax, %r12
leaq 0x451c(%rip), %rbx      # 0xf4cf
leaq 0x4518(%rip), %r14      # 0xf4d2
leaq 0x42de(%rip), %r15      # 0xf29f
movq %rbx, %rdi
callq 0xa184
testq %rax, %rax
je 0xafd5
movl $0x5, %edi
jmp 0xaffb
movq %r14, %rdi
callq 0xa184
testq %rax, %rax
je 0xafe9
movl $0x6, %edi
jmp 0xaffb
movq %r15, %rdi
callq 0xa184
testq %rax, %rax
je 0xb018
movl $0x7, %edi
movq %rax, %rsi
callq 0x9c68
movq %rax, %r13
movq %r12, 0x18(%rax)
callq 0xb025
movq %rax, 0x20(%r13)
movq %r13, %r12
jmp 0xafc1
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8127(%rip), %rdi      # 0x13158
leaq 0x481a(%rip), %rsi      # 0xf852
callq 0xda40
testb %al, %al
je 0xb0e4
leaq 0x810c(%rip), %rdi      # 0x13158
xorl %eax, %eax
movq (%rdi), %rdi
testb $0x1, %al
movb $0x1, %al
je 0xb04e
callq 0xb115
testl %eax, %eax
je 0xb0e4
movq 0x80ed(%rip), %rbx      # 0x13158
movq (%rbx), %rax
movq %rax, 0x80e3(%rip)      # 0x13158
callq 0xa6d2
movq %rax, %r14
leaq 0x444b(%rip), %rdi      # 0xf4cf
callq 0xa184
testq %rax, %rax
je 0xb0ad
leaq 0x443a(%rip), %r15      # 0xf4cf
movq %r14, %rdi
callq 0x9d9e
movq %rax, %r14
movq %r15, %rdi
callq 0xa184
testq %rax, %rax
jne 0xb095
leaq 0x423e(%rip), %rdi      # 0xf2f2
callq 0xa184
testq %rax, %rax
je 0xb0ee
movl $0x28, %edi
movq %rbx, %rsi
callq 0x9c68
movq %rax, %rbx
movq %r14, 0x10(%rax)
callq 0xb025
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
popq %rbx
popq %r14
popq %r15
jmp 0xb180
movq 0x8063(%rip), %rbx      # 0x13158
leaq 0x2f54(%rip), %rdi      # 0xe050
leaq 0x41ef(%rip), %rsi      # 0xf2f2
xorl %eax, %eax
callq 0xd7f2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xce4d
// File: /workspace/github_c_makefile_star2_O1/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 0x4117(%rip), %rsi      # 0xf23b
callq 0xda40
movl $0x1, %ebx
testb %al, %al
jne 0xb178
leaq 0x4132(%rip), %rsi      # 0xf26b
movq %r14, %rdi
callq 0xda40
testb %al, %al
jne 0xb178
movl 0x8(%r14), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0xb176
leaq 0x8010(%rip), %r15      # 0x13168
movq (%r15), %r15
testq %r15, %r15
je 0xb176
movq 0x10(%r14), %rdi
movq 0x8(%r15), %rsi
callq 0xd952
testl %eax, %eax
je 0xb158
testq %r15, %r15
jne 0xb178
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, (%rsp)
leaq 0x789c(%rip), %r12      # 0x13180
movq (%r12), %r12
testq %r12, %r12
je 0xb92a
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0xd952
testl %eax, %eax
je 0xb8e4
movq 0x8(%r12), %r13
movq 0x10(%r12), %rbp
movslq 0x18(%r12), %rbx
movl $0x1, %edi
movq (%rsp), %rsi
callq 0x9c68
movq %rax, %r15
movq %r13, 0x40(%rax)
movq %rbp, 0x10(%rax)
movq %rbx, 0x48(%rax)
testq %r12, %r12
jne 0xb9b7
leaq 0x7826(%rip), %r12      # 0x13160
movq (%r12), %r12
testq %r12, %r12
je 0xb977
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0xd952
testl %eax, %eax
je 0xb93a
movq 0x8(%r12), %rbx
movq 0x10(%r12), %r13
movl $0x2, %edi
movq (%rsp), %rsi
callq 0x9c68
movq %rax, %r15
movq %rbx, 0x40(%rax)
movq %r13, 0x10(%rax)
testq %r12, %r12
jne 0xb9b7
leaq 0x77f5(%rip), %r12      # 0x13178
movq (%r12), %r12
testq %r12, %r12
je 0xb9b2
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0xd952
testl %eax, %eax
je 0xb983
movq 0x10(%r12), %rdi
callq 0x9cec
movq %rax, %r15
movq (%rsp), %rax
movq %rax, 0x8(%r15)
testq %r12, %r12
je 0xb9c9
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38e5(%rip), %rdi      # 0xf2b5
movq %r14, %rsi
xorl %eax, %eax
callq 0xd7f2
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xce4d
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
callq 0xab23
movq %rax, %rbx
leaq 0x2654(%rip), %rdi      # 0xe04e
callq 0xa184
testq %rax, %rax
je 0xba3a
leaq 0x2643(%rip), %r14      # 0xe04e
movl $0x15, %edi
movq %rax, %rsi
callq 0x9c68
movq %rax, %r15
movq %rbx, 0x18(%rax)
callq 0xab23
movq %rax, 0x20(%r15)
movq %r14, %rdi
callq 0xa184
movq %r15, %rbx
testq %rax, %rax
jne 0xba0b
jmp 0xba3d
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9c8c
movq %rax, %r15
addq 0x772d(%rip), %r15      # 0x13190
movq %r15, 0x7726(%rip)      # 0x13190
movl $0x20, %edi
movl $0x1, %esi
callq 0x20f0
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movl %r15d, 0x18(%rax)
movq 0x76f4(%rip), %rcx      # 0x13180
movq %rcx, (%rax)
movq %rax, 0x76ea(%rip)      # 0x13180
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa6d2
movq %rax, %rdi
callq 0xaa49
movq %rax, %r15
movq 0x10(%rax), %rsi
movq 0x40(%rax), %rdi
callq 0xba46
leaq 0x3243(%rip), %rdi      # 0xf29d
callq 0xa184
testq %rax, %rax
je 0xc10e
movq %rax, %r14
movl $0x15, %edi
movq %rax, %rsi
callq 0x9c68
movq %rax, %rbx
movq %r15, 0x18(%rax)
movq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0xb8cb
movq %rax, %r15
leaq 0x31b6(%rip), %rdi      # 0xf24b
callq 0xa184
testq %rax, %rax
je 0xc0e7
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xc11d
movq %rax, %r14
leaq 0x30d3(%rip), %rdi      # 0xf189
callq 0xa184
testq %rax, %rax
jne 0xc107
movq 0x7091(%rip), %rbx      # 0x13158
leaq 0x1f82(%rip), %rdi      # 0xe050
leaq 0x30b4(%rip), %rsi      # 0xf189
xorl %eax, %eax
callq 0xd7f2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xce4d
callq 0xab23
movq %rax, %r12
movl $0x17, %edi
movq %r14, %rsi
callq 0x9c68
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_O1/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
xorl %edi, %edi
movq %r14, %rsi
callq 0x9c68
movq %rax, %r15
movl %ebp, 0x28(%rax)
callq 0x9d54
movq %rax, 0x10(%r15)
movl $0x1a, %edi
movq %r14, %rsi
callq 0x9c68
movq %rax, %r12
movl $0x3, %edi
movq %r14, %rsi
callq 0x9c68
movq %rax, 0x38(%r12)
movq %rbx, 0x18(%rax)
movq %r15, 0x20(%rax)
callq 0xab23
movq %rax, %r13
movl $0x17, %edi
movq %r14, %rsi
callq 0x9c68
movq %rax, %r15
movq %r12, 0x18(%rax)
movq %r13, 0x20(%rax)
movq 0x6fbe(%rip), %rdi      # 0x13158
leaq 0x2fe8(%rip), %rsi      # 0xf189
callq 0xda40
testb %al, %al
je 0xc1c0
movl $0x15, %edi
movq %r14, %rsi
callq 0x9c68
movq %rax, %r12
movq %r15, 0x18(%rax)
jmp 0xc1f7
leaq 0x1e87(%rip), %rdi      # 0xe04e
callq 0xa184
testq %rax, %rax
je 0xc20e
movl $0x15, %edi
movq %r14, %rsi
callq 0x9c68
movq %rax, %r12
movq %r15, 0x18(%rax)
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0xc11d
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 0x6f43(%rip), %rbx      # 0x13158
leaq 0x1e34(%rip), %rdi      # 0xe050
leaq 0x1e2b(%rip), %rsi      # 0xe04e
xorl %eax, %eax
callq 0xd7f2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xce4d
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/parse.c
// Function: expr_stmt
static Node *expr_stmt() {
  Node *node = new_node(NEXPR_STMT, peek(0));
  node->expr = expr();
  if (!match(";")) {
    parse_error("expr stmt: ;", peek(0));
  }
  return node;
}

// Assembly:
pushq %rbx
movq 0x6f1b(%rip), %rsi      # 0x13158
movl $0x1c, %edi
callq 0x9c68
movq %rax, %rbx
callq 0xb9e6
movq %rax, 0x38(%rbx)
leaq 0x30ef(%rip), %rdi      # 0xf349
callq 0xa184
testq %rax, %rax
je 0xc269
movq %rbx, %rax
popq %rbx
retq
movq 0x6ee8(%rip), %rbx      # 0x13158
leaq 0x1dd9(%rip), %rdi      # 0xe050
leaq 0x30e1(%rip), %rsi      # 0xf35f
xorl %eax, %eax
callq 0xd7f2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xce4d
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x7, %edi
movl $0x8, %esi
callq 0x20f0
movq %rax, %rbx
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xc2ea
movq (%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %r14
xorl %esi, %esi
movq (%rbx,%rsi,8), %rdi
testq %rdi, %rdi
je 0xc2db
movl 0x10(%r14), %r8d
cmpl 0x14(%rdi), %r8d
jge 0xc2db
incq %rsi
cmpq $0x6, %rsi
jne 0xc2bd
jmp 0xc2f2
movl %esi, (%r14)
movq %r14, (%rbx,%rsi,8)
incq %rdx
cmpq %rax, %rdx
jne 0xc2b7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, 0x30(%rbx)
movq %rbx, %rdi
callq 0xc32e
movl %eax, (%r14)
cltq
movq (%rbx,%rax,8), %rcx
movl $0x6, (%rcx)
movb $0x1, 0x18(%rcx)
movq %r14, (%rbx,%rax,8)
movq %r14, %rdi
callq 0x8d4d
leaq 0x3048(%rip), %rdi      # 0xf36c
movq %rax, %rsi
xorl %eax, %eax
callq 0xd8b8
// File: /workspace/github_c_makefile_star2_O1/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 %edx, %edx
movl $0x1, %ecx
movslq %edx, %rax
movq (%rdi,%rax,8), %rax
movl 0x14(%rax), %esi
movq (%rdi,%rcx,8), %r8
movl %ecx, %eax
cmpl 0x14(%r8), %esi
jl 0xc34d
movl %edx, %eax
incq %rcx
movl %eax, %edx
cmpq $0x7, %rcx
jne 0xc335
retq
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/sema.c
// Function: sema
void sema(Program* prog) {
  for (GVar* gvar = prog->globals; gvar != NULL; gvar = gvar->next) {
    walk(gvar->init);
    if (gvar->inits != NULL) {
      for (size_t i = 0; i < gvar->inits->length; i++) {
        walk(gvar->inits->ptr[i]);
      }
    }
  }

  funcs = prog->funcs;
  switches = new_vec();
  for (size_t i = 0; i < prog->funcs->length; i++) {
    Function* fn = prog->funcs->ptr[i];
    if (fn->body)
      walk(fn->body);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0xc609
movq 0x18(%r14), %rdi
callq 0xc655
cmpq $0x0, 0x20(%r14)
je 0xc604
movq 0x20(%r14), %rax
cmpq $0x0, 0x10(%rax)
je 0xc604
xorl %r15d, %r15d
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
callq 0xc655
incq %r15
movq 0x20(%r14), %rax
cmpq 0x10(%rax), %r15
jb 0xc5eb
movq (%r14), %r14
jmp 0xc5c8
movq (%rbx), %rax
movq %rax, 0x6b85(%rip)      # 0x13198
xorl %eax, %eax
callq 0x307c
movq %rax, 0x6b7f(%rip)      # 0x131a0
movq (%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0xc64f
xorl %r14d, %r14d
movq (%rax), %rax
movq (%rax,%r14,8), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xc643
callq 0xc655
incq %r14
movq (%rbx), %rax
cmpq 0x10(%rax), %r14
jb 0xc62e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/sema.c
// Function: rewrite_arith_node
static void rewrite_arith_node(Node* node) {
  /* ポインタ演算を通常の整数演算に置き換える */
  if (type_of(node->lhs)->ty == TY_PTR && type_of(node->rhs)->ty != TY_PTR) {
    Node* rhs = node->rhs;
    Node* new = new_node(NMUL, rhs->token);
    new->lhs = rhs;
    new->rhs = new_node(NINT, rhs->token);
    new->rhs->integer = size_of(type_of(node->lhs)->ptr_to);
    new->rhs->type = ptr_to(type_of(node->lhs)->ptr_to);
    new->type = new->rhs->type;
    node->rhs = new;
  } else if (type_of(node->rhs)->ty == TY_PTR && type_of(node->lhs)->ty != TY_PTR) {
    Node* lhs = node->lhs;
    Node* new = new_node(NMUL, lhs->token);
    new->lhs = lhs;
    new->rhs = new_node(NINT, lhs->token);
    new->rhs->integer = size_of(type_of(node->rhs)->ptr_to);
    new->rhs->type = ptr_to(type_of(node->lhs)->ptr_to);
    new->type = new->rhs->type;
    node->lhs = new;
  }

  Type* type = arith_conv(type_of(node->lhs), type_of(node->rhs));

  node->type = type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq 0x18(%rdi), %rdi
callq 0x9e0f
cmpl $0x4, (%rax)
jne 0xcbb6
movq 0x20(%rbx), %rdi
callq 0x9e0f
cmpl $0x4, (%rax)
jne 0xcbda
movq 0x20(%rbx), %rdi
callq 0x9e0f
cmpl $0x4, (%rax)
jne 0xcc43
movq (%r15), %rdi
callq 0x9e0f
cmpl $0x4, (%rax)
je 0xcc43
leaq 0x20(%rbx), %r13
movq %r15, %r12
jmp 0xcbe1
leaq 0x20(%rbx), %r12
movq %r15, %r13
movq (%r12), %rbp
movq 0x8(%rbp), %rsi
movl $0x5, %edi
callq 0x9c68
movq %rax, %r14
movq %rbp, 0x18(%rax)
movq 0x8(%rbp), %rsi
xorl %edi, %edi
callq 0x9c68
movq %rax, 0x20(%r14)
movq (%r13), %rdi
callq 0x9e0f
movq 0x18(%rax), %rdi
callq 0x9c8c
movq 0x20(%r14), %rcx
movl %eax, 0x28(%rcx)
movq (%r15), %rdi
callq 0x9e0f
movq 0x18(%rax), %rdi
callq 0x9d9e
movq 0x20(%r14), %rcx
movq %rax, 0x10(%rcx)
movq %rax, 0x10(%r14)
movq %r14, (%r12)
movq 0x18(%rbx), %rdi
callq 0x9e0f
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x9e0f
movq %r14, %rdi
movq %rax, %rsi
callq 0xcc76
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/sema.c
// Function: arith_conv
static Type* arith_conv(Type* t1, Type* t2) {
  Type* type = NULL;

  if (t1->ty == TY_STRUCT || t2->ty == TY_STRUCT) {
    error("error(arith_conv):");
    dump_type(t1);
    eprintf("\n");
    dump_type(t2);
    eprintf("\n");
  }

  /* 左辺と右辺のサイズが大きい方の型をnodeに割り当てる */
  if (size_of(t1) >= size_of(t2)) {
    type = t1;
  } else {
    type = t2;
  }

  if (type->array_size != 0) {
    /* 配列型になった場合はポインタ型に変換する */
    type = clone_type(type);
    type->array_size = 0;
  }

  return type;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x5, (%rdi)
je 0xccc5
movq %rsi, %r14
cmpl $0x5, (%rsi)
je 0xccc5
movq %rdi, %rbx
callq 0x9c8c
movq %rax, %r15
movq %r14, %rdi
callq 0x9c8c
cmpq %rax, %r15
cmovbq %r14, %rbx
cmpq $0x0, 0x20(%rbx)
je 0xccbc
movq %rbx, %rdi
callq 0x9cb9
movq %rax, %rbx
movq $0x0, 0x20(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2775(%rip), %rdi      # 0xf441
xorl %eax, %eax
callq 0xd8b8
// File: /workspace/github_c_makefile_star2_O1/takoeight0821[P]hoc_nyan/src/sema.c
// Function: ret_type
static Type* ret_type(char* name) {
  for (size_t i = 0; i < funcs->length; i++) {
    Function* fn = funcs->ptr[i];
    if (streq(name, fn->name)) {
      return fn->ret_type;
    }
  }
  eprintf("undefined function %s\n", name);
  return int_type();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x64b3(%rip), %rax      # 0x13198
cmpq $0x0, 0x10(%rax)
setne %bpl
je 0xcd29
xorl %r15d, %r15d
movq (%rax), %rax
movq (%rax,%r15,8), %r12
movq (%r12), %rsi
movq %rbx, %rdi
callq 0xd952
testl %eax, %eax
je 0xcd0f
movq 0x8(%r12), %r14
testl %eax, %eax
jne 0xcd29
incq %r15
movq 0x647b(%rip), %rax      # 0x13198
cmpq 0x10(%rax), %r15
setb %bpl
jb 0xccf3
jmp 0xcd29
testb $0x1, %bpl
je 0xcd3b
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2712(%rip), %rdi      # 0xf454
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9d54
nopl (%rax)