LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x13, %edi
callq 0x8d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x16, %edi
callq 0x8d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: store
static IR* store(IReg* dst, IReg* src) {
  assert(dst);
  assert(src);
  IR* new = new_ir(ISTORE);
  new->r1 = dst;
  new->r2 = src;
  return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7639
jmp 0x7658
leaq 0xb5e1(%rip), %rdi      # 0x12c21
leaq 0xb5de(%rip), %rsi      # 0x12c25
movl $0x69, %edx
leaq 0xb6d8(%rip), %rcx      # 0x12d2b
callq 0x20b0
cmpq $0x0, -0x10(%rbp)
je 0x7661
jmp 0x7680
leaq 0xb6dd(%rip), %rdi      # 0x12d45
leaq 0xb5b6(%rip), %rsi      # 0x12c25
movl $0x6a, %edx
leaq 0xb6b0(%rip), %rcx      # 0x12d2b
callq 0x20b0
movl $0x15, %edi
callq 0x8d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: bitwise_not
static IR* bitwise_not(IReg* reg, IReg* val) {
  IR* new = new_ir(INOT);
  new->r0 = reg;
  new->r1 = val;
  return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x8d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: label
static IR* label(IReg* reg, char* name) {
  IR* new = calloc(1, sizeof(IR));
  new->op = ILABEL;
  new->r0 = reg;
  new->label = name;
  return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0x20d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x797c
jmp 0x7ace
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x799c
jmp 0x798b
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x7a2b
jmp 0x7aba
movq -0x8(%rbp), %rdi
callq 0x9d60
cmpq $0x1, %rax
jne 0x79c2
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0xb43c(%rip), %rdi      # 0x12df5
movb $0x0, %al
callq 0x7ae0
jmp 0x7a26
movq -0x8(%rbp), %rdi
callq 0x9d60
cmpq $0x4, %rax
jne 0x79e8
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0xb41c(%rip), %rdi      # 0x12dfb
movb $0x0, %al
callq 0x7ae0
jmp 0x7a24
movq -0x8(%rbp), %rdi
callq 0x9d60
cmpq $0x8, %rax
jne 0x7a0e
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0xb3fc(%rip), %rdi      # 0x12e01
movb $0x0, %al
callq 0x7ae0
jmp 0x7a22
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xa73f(%rip), %rsi      # 0x1215c
callq 0xed90
jmp 0x7a24
jmp 0x7a26
jmp 0x7ace
movq -0x8(%rbp), %rdi
callq 0x9d60
cmpq $0x1, %rax
jne 0x7a52
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
leaq 0xb3be(%rip), %rdi      # 0x12e07
movb $0x0, %al
callq 0x7ae0
jmp 0x7ab8
movq -0x8(%rbp), %rdi
callq 0x9d60
cmpq $0x4, %rax
jne 0x7a79
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
leaq 0xb39d(%rip), %rdi      # 0x12e0d
movb $0x0, %al
callq 0x7ae0
jmp 0x7ab6
movq -0x8(%rbp), %rdi
callq 0x9d60
cmpq $0x8, %rax
jne 0x7aa0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
leaq 0xb37c(%rip), %rdi      # 0x12e13
movb $0x0, %al
callq 0x7ae0
jmp 0x7ab4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xa6ad(%rip), %rsi      # 0x1215c
callq 0xed90
jmp 0x7ab6
jmp 0x7ab8
jmp 0x7ace
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xa6d2(%rip), %rsi      # 0x1219b
callq 0xed90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_x86.c
// Function: emit_function
static void emit_function(IFunc* func) {
  if (!func->blocks) {
    printf("extern %s\n", func->name);
    return;
  }

  func_end_label = new_label("end");

  if (!func->is_static) {
    printf("global %s\n", func->name);
  }
  printf("%s:\n", func->name);

  emit("push rbp");
  emit("mov rbp, rsp");

  if (func->has_va_arg) {
    set_reg_nums(func->params);
    emit_regsave_area();
  }

  emit("sub rsp, %d", count_stack_size(func));
  emit("and rsp, -16");

  for (size_t i = 0; i < func->blocks->length; i++) {
    emit_block(func->blocks->ptr[i]);
  }

  printf("%s:\n", func_end_label);
  emit("mov rsp, rbp");
  emit("pop rbp");
  emit("ret");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x7bd1
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0xb1f3(%rip), %rdi      # 0x12db8
movb $0x0, %al
callq 0x2090
jmp 0x7cf6
leaq 0xa60d(%rip), %rdi      # 0x121e5
callq 0x7d00
movq %rax, 0xfa8c(%rip)      # 0x17670
movq -0x8(%rbp), %rax
testb $0x1, 0x8(%rax)
jne 0x7c03
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0xa5ee(%rip), %rdi      # 0x121ea
movb $0x0, %al
callq 0x2090
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0xa522(%rip), %rdi      # 0x12133
movb $0x0, %al
callq 0x2090
leaq 0xa5d6(%rip), %rdi      # 0x121f5
movb $0x0, %al
callq 0x7ae0
leaq 0xa5d1(%rip), %rdi      # 0x121fe
movb $0x0, %al
callq 0x7ae0
movq -0x8(%rbp), %rax
testb $0x1, 0x9(%rax)
je 0x7c50
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7d40
callq 0x7d60
movq -0x8(%rbp), %rdi
callq 0x8e10
movl %eax, %esi
leaq 0xa5ca(%rip), %rdi      # 0x1222c
movb $0x0, %al
callq 0x7ae0
leaq 0xada7(%rip), %rdi      # 0x12a17
movb $0x0, %al
callq 0x7ae0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7cb7
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7e40
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7c7f
movq 0xf9b2(%rip), %rsi      # 0x17670
leaq 0xa46e(%rip), %rdi      # 0x12133
movb $0x0, %al
callq 0x2090
leaq 0xb146(%rip), %rdi      # 0x12e19
movb $0x0, %al
callq 0x7ae0
leaq 0xb145(%rip), %rdi      # 0x12e26
movb $0x0, %al
callq 0x7ae0
leaq 0xa52f(%rip), %rdi      # 0x1221e
movb $0x0, %al
callq 0x7ae0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_x86.c
// Function: get_reg
static char* get_reg(int rn, size_t size) {
  switch (size) {
  case 1: return regs8[rn];
  case 4: return regs32[rn];
  default: return regs[rn]; // sizeが8以上なら配列
    // FIXME: 型に応じて使うレジスタを決めるように変更
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
subq $0x1, %rax
je 0x8c47
jmp 0x8c3b
movq -0x20(%rbp), %rax
subq $0x4, %rax
je 0x8c5c
jmp 0x8c71
movslq -0xc(%rbp), %rcx
leaq 0xe61e(%rip), %rax      # 0x17270
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x8c84
movslq -0xc(%rbp), %rcx
leaq 0xe649(%rip), %rax      # 0x172b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x8c84
movslq -0xc(%rbp), %rcx
leaq 0xe674(%rip), %rax      # 0x172f0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_x86.c
// Function: emit_builtin_va_start
static void emit_builtin_va_start(IReg* addr) {
  emit("push rcx");
  emit("mov rax, %s", get_reg(addr->real_reg, 8));
  emit("mov dword [rax], %d", numgp * 8);
  emit("mov dword [rax + 4], 48");
  emit("lea rcx, [rbp - %d]", REGAREA_SIZE);
  emit("mov [rax + 16], rcx");
  emit("pop rcx");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xa27d(%rip), %rdi      # 0x12f60
movb $0x0, %al
callq 0x7ae0
movq -0x8(%rbp), %rax
movl (%rax), %edi
movl $0x8, %esi
callq 0x8c20
movq %rax, %rsi
leaq 0xa265(%rip), %rdi      # 0x12f69
movb $0x0, %al
callq 0x7ae0
movl 0xe96b(%rip), %esi      # 0x1767c
shll $0x3, %esi
leaq 0xa25a(%rip), %rdi      # 0x12f75
movb $0x0, %al
callq 0x7ae0
leaq 0xa260(%rip), %rdi      # 0x12f89
movb $0x0, %al
callq 0x7ae0
leaq 0x9c9b(%rip), %rdi      # 0x129d2
movl $0xb0, %esi
movb $0x0, %al
callq 0x7ae0
leaq 0x9c9c(%rip), %rdi      # 0x129e6
movb $0x0, %al
callq 0x7ae0
leaq 0xa249(%rip), %rdi      # 0x12fa1
movb $0x0, %al
callq 0x7ae0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %edi
callq 0x8d70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x8eb2
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x8ea2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x12, (%rax)
jne 0x8e95
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x8e97
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8e56
jmp 0x8ea4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8e26
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/ir.c
// Function: show_args
static char* show_args(Vector* args) {
  StringBuilder* sb = new_sb();
  sb_puts(sb, "(");
  for (int i = 0; i < args->length; i++) {
    if (i) {
      sb_puts(sb, " ");
    }
    sb_puts(sb, show_ireg(args->ptr[i]));
  }
  sb_puts(sb, ")");
  return sb_run(sb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0xfcd0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa2ae(%rip), %rsi      # 0x139ce
callq 0xfdc0
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x9783
cmpl $0x0, -0x14(%rbp)
je 0x9750
movq -0x10(%rbp), %rdi
leaq 0x8ad8(%rip), %rsi      # 0x12223
callq 0xfdc0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8ec0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xfdc0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x972c
movq -0x10(%rbp), %rdi
leaq 0x9b74(%rip), %rsi      # 0x13302
callq 0xfdc0
movq -0x10(%rbp), %rdi
callq 0xfe20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xfcd0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x99ac(%rip), %rdi      # 0x1318b
movb $0x0, %al
callq 0xfa70
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xfdc0
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x9888
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0x9972(%rip), %rdi      # 0x13192
movb $0x0, %al
callq 0xfa70
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xfdc0
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8f10
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xfdc0
movq -0x18(%rbp), %rdi
leaq 0x9dd2(%rip), %rsi      # 0x1363c
callq 0xfdc0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x97f9
movq -0x18(%rbp), %rdi
leaq 0x9906(%rip), %rsi      # 0x13199
callq 0xfdc0
movq -0x18(%rbp), %rdi
callq 0xfe20
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x98e5
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x98c6(%rip), %rdi      # 0x1319b
movb $0x0, %al
callq 0xfa70
movq %rax, -0x8(%rbp)
jmp 0x9a17
callq 0xfcd0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x9892(%rip), %rdi      # 0x131a5
movb $0x0, %al
callq 0xfa70
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xfdc0
movq -0x18(%rbp), %rdi
leaq 0x9884(%rip), %rsi      # 0x131b5
callq 0xfdc0
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x9996
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8ec0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xfdc0
movq -0x18(%rbp), %rdi
leaq 0x889d(%rip), %rsi      # 0x12223
callq 0xfdc0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x993d
movq -0x18(%rbp), %rdi
leaq 0x9c9b(%rip), %rsi      # 0x1363c
callq 0xfdc0
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x9a0a
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x1c(%rbp), %rdi
callq 0x97b0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xfdc0
movq -0x18(%rbp), %rdi
leaq 0x9c42(%rip), %rsi      # 0x1363c
callq 0xfdc0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x99ad
movq -0x18(%rbp), %rdi
callq 0xfe20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0xfcd0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x9a93
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x98b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xfdc0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9a4c
movq -0x10(%rbp), %rdi
callq 0xfe20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x90, %esi
callq 0x20d0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x20d0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9ed0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9d60
movq -0x20(%rbp), %rcx
imulq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9fe1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0x9fd2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa0a6
jmp 0x9fd4
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9fa8
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa09e
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0xa08c
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9f90
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa08a
movl $0x1, %edi
movl $0x20, %esi
callq 0x20d0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x30(%rbp), %rax
addq 0x18(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa0a6
jmp 0xa08c
jmp 0xa08e
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9fe9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9f90
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa0e6
leaq 0x90fd(%rip), %rdi      # 0x131dc
movb $0x0, %al
callq 0xfb50
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9f90
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa136
leaq 0x90c5(%rip), %rdi      # 0x131f4
movb $0x0, %al
callq 0xfb50
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0xd519(%rip)      # 0x17680
callq 0xa1e0
movl $0x1, %edi
movl $0x10, %esi
callq 0x20d0
movq %rax, -0x10(%rbp)
movb $0x0, %al
callq 0x2280
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0xd4e8(%rip)      # 0x17680
je 0xa1bc
callq 0xa2a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa1ba
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x22e0
jmp 0xa190
movq 0xd4c5(%rip), %rcx      # 0x17688
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: init_typedef
static void init_typedef(void) {
  add_typedef("void", void_type());
  add_typedef("char", char_type());
  add_typedef("int", int_type());
  add_typedef("long", long_type());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x9e50
movq %rax, %rsi
leaq 0x901b(%rip), %rdi      # 0x1320e
callq 0xa240
callq 0x9e70
movq %rax, %rsi
leaq 0x900c(%rip), %rdi      # 0x13213
callq 0xa240
callq 0x9e90
movq %rax, %rsi
leaq 0x8ffd(%rip), %rdi      # 0x13218
callq 0xa240
callq 0x9eb0
movq %rax, %rsi
leaq 0x8fed(%rip), %rdi      # 0x1321c
callq 0xa240
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x20d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0xd40e(%rip), %rcx      # 0x17690
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, 0xd3fc(%rip)      # 0x17690
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: toplevel
static Function *toplevel() {
  if (match("typedef")) {
    type_alias_def();
    return NULL;
  } else if (match("extern")) {
    global_var();
    global_env->is_extern = true;
    return NULL;
  } else if (match("static")) {
    return funcdef(true);
  } else {
    return funcdef(false);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x8f72(%rip), %rdi      # 0x13221
callq 0xa330
cmpq $0x0, %rax
je 0xa2c9
callq 0xa3a0
movq $0x0, -0x8(%rbp)
jmp 0xa322
leaq 0x8f59(%rip), %rdi      # 0x13229
callq 0xa330
cmpq $0x0, %rax
je 0xa2f5
callq 0xa440
movq 0xd3a1(%rip), %rax      # 0x17688
movb $0x1, 0x28(%rax)
movq $0x0, -0x8(%rbp)
jmp 0xa322
leaq 0x8f34(%rip), %rdi      # 0x13230
callq 0xa330
cmpq $0x0, %rax
je 0xa317
movl $0x1, %edi
callq 0xa5e0
movq %rax, -0x8(%rbp)
jmp 0xa322
xorl %edi, %edi
callq 0xa5e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xa970
cmpl $0x3, %eax
jne 0xa381
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0xa381
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, -0x18(%rbp)
callq 0xa9e0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa389
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: type_alias_def
static void type_alias_def(void) {
  Type *ty = type_specifier();
  if (peek_tag(0) != TIDENT) {
    parse_error("ident", peek(0));
  }
  char *tag = peek(0)->ident;
  consume();
  ty = read_type_suffix(ty);
  add_typedef(tag, ty);
  if (!match(";")) {
    parse_error("type alias: ;", peek(0));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xaad0
movq %rax, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xa970
cmpl $0x2, %eax
je 0xa3d7
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
leaq 0x8e65(%rip), %rdi      # 0x13237
callq 0xaa00
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
callq 0xa9e0
movq -0x8(%rbp), %rdi
callq 0xaa40
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xa240
leaq 0x8f4b(%rip), %rdi      # 0x13359
callq 0xa330
cmpq $0x0, %rax
jne 0xa431
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
leaq 0x8e11(%rip), %rdi      # 0x1323d
callq 0xaa00
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0xaad0
movq %rax, -0x8(%rbp)
leaq 0x91f1(%rip), %rdi      # 0x13649
callq 0xa330
cmpq $0x0, %rax
je 0xa472
movq -0x8(%rbp), %rdi
callq 0x9ed0
movq %rax, -0x8(%rbp)
jmp 0xa451
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, -0x10(%rbp)
callq 0xae80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaa40
movq %rax, -0x8(%rbp)
leaq 0x8e11(%rip), %rdi      # 0x132ad
callq 0xa330
cmpq $0x0, %rax
je 0xa58f
leaq 0x8da9(%rip), %rdi      # 0x1325b
callq 0xa330
cmpq $0x0, %rax
je 0xa557
movb $0x0, %al
callq 0x2280
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xb240
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x22e0
leaq 0x7b62(%rip), %rdi      # 0x1204e
callq 0xa330
cmpq $0x0, %rax
je 0xa512
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xb240
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x22e0
jmp 0xa4e5
leaq 0x8c80(%rip), %rdi      # 0x13199
callq 0xa330
cmpq $0x0, %rax
jne 0xa53c
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
leaq 0x8c62(%rip), %rdi      # 0x13199
callq 0xaa00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0xb1c0
jmp 0xa58d
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xc7b0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0xb1c0
jmp 0xa5a8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0xb1c0
leaq 0x8daa(%rip), %rdi      # 0x13359
callq 0xa330
cmpq $0x0, %rax
jne 0xa5d2
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
leaq 0x8cbd(%rip), %rdi      # 0x1328a
callq 0xaa00
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: peek
static Token *peek(size_t i) {
  Token *t = tokens;
  // i回nextをたどるとi+1個目の要素になる
  for (size_t j = i; j > 0; j--) {
    t = t->next;
  }
  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq 0xcce1(%rip), %rax      # 0x17680
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0xa9cb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa9ab
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x882d(%rip), %rdi      # 0x13280
callq 0xa330
cmpq $0x0, %rax
jne 0xaa68
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaac6
xorl %edi, %edi
leaq 0x8811(%rip), %rsi      # 0x13282
callq 0xb100
movslq 0xc(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x83f9(%rip), %rdi      # 0x12e7e
callq 0xa330
cmpq $0x0, %rax
jne 0xaaa8
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
leaq 0x83db(%rip), %rdi      # 0x12e7e
callq 0xaa00
movq -0x10(%rbp), %rdi
callq 0xaa40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9f10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: find_tag
static Type *find_tag(char *tag_name) {
  for (Tag *tag = tag_env; tag != NULL; tag = tag->next) {
    if (streq(tag_name, tag->type->tag)) {
      return tag->type;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xc945(%rip), %rax      # 0x17698
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xad95
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0xad86
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xad9d
jmp 0xad88
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xad57
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: set_field_offset
static void set_field_offset(Type *t) {
  size_t offset = 0;
  for (Field *f = t->fields; f != NULL; f = f->next) {
    offset = roundup(offset, f->type->align);
    f->offset = offset;
    offset += size_of(f->type);
    if (t->align < f->type->align) {
      t->align = f->type->align;
    }
  }
  t->size = roundup(offset, t->align);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xae50
movq -0x10(%rbp), %rax
movl %eax, %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
callq 0xfa50
cltq
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x9d60
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0xae41
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xae43
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xadd0
movq -0x10(%rbp), %rax
movl %eax, %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
callq 0xfa50
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: add_enum
static void add_enum(char *name, int val) {
  Enum *e = calloc(1, sizeof(Enum));
  e->name = name;
  e->val = new_int_node(NULL, val);
  e->next = enum_env;
  enum_env = e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x20d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %esi
xorl %eax, %eax
movl %eax, %edi
callq 0xb170
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0xc7a4(%rip), %rcx      # 0x176a0
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, 0xc792(%rip)      # 0x176a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xc75d(%rip), %rax      # 0x17690
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xaf71
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0xaf62
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xaf79
jmp 0xaf64
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xaf37
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x83ba(%rip), %rdi      # 0x13359
callq 0xa330
leaq 0x81ee(%rip), %rdi      # 0x13199
callq 0xa330
cmpq $0x0, %rax
je 0xafc0
movq $0x0, -0x8(%rbp)
jmp 0xb01b
callq 0xaad0
movq %rax, %rdi
callq 0xb030
movq %rax, -0x10(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x20d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0xaf90
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: direct_decl
static Node *direct_decl(Type *ty) {
  if (peek_tag(0) != TIDENT) {
    parse_error("ident", peek(0));
  }
  Node *node = new_node(NDEFVAR, peek(0));
  node->name = peek(0)->ident;
  /*
  if (find_type(node->name)) {
    bad_token(peek(0), format("%s is a type name.", node->name));
  }
  */

  consume();

  node->type = read_type_suffix(ty);

  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xa970
cmpl $0x2, %eax
je 0xb0a2
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
leaq 0x819a(%rip), %rdi      # 0x13237
callq 0xaa00
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
movl $0x16, %edi
callq 0x9d10
movq %rax, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
callq 0xa9e0
movq -0x8(%rbp), %rdi
callq 0xaa40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xa970
cmpl -0xc(%rbp), %eax
jne 0xb137
movq 0xc55c(%rip), %rax      # 0x17680
movq %rax, -0x20(%rbp)
callq 0xa9e0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb15c
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xaa00
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0x9d10
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
callq 0x9e90
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x30, %edi
movl $0x1, %esi
callq 0x20d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq 0xc462(%rip), %rcx      # 0x17688
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, 0xc450(%rip)      # 0x17688
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0xb420
movq %rax, -0x8(%rbp)
leaq 0x8055(%rip), %rdi      # 0x132ad
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb297
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0xb240
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq %rax, %rcx
xorl %esi, %esi
callq 0xb380
movq %rax, -0x8(%rbp)
jmp 0xb370
leaq 0x7ffa(%rip), %rdi      # 0x13298
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb2e0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xb240
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movl $0x3, %esi
callq 0xb380
movq %rax, -0x8(%rbp)
jmp 0xb36e
leaq 0x7fb4(%rip), %rdi      # 0x1329b
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb326
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xb240
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
movl $0x4, %esi
callq 0xb380
movq %rax, -0x8(%rbp)
jmp 0xb36c
leaq 0x7f71(%rip), %rdi      # 0x1329e
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb36a
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0xb240
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq %rax, %rcx
movl $0x5, %esi
callq 0xb380
movq %rax, -0x8(%rbp)
jmp 0xb36c
jmp 0xb36e
jmp 0xb370
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movl $0x17, %edi
callq 0x9d10
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpl $0x0, -0x14(%rbp)
je 0xb3fc
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x9d10
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb410
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xb490
movq %rax, -0x8(%rbp)
leaq 0x7e69(%rip), %rdi      # 0x132a1
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb47f
movq -0x10(%rbp), %rsi
movl $0x14, %edi
callq 0x9d10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb490
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb489
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0xb431
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xb500
movq %rax, -0x8(%rbp)
leaq 0x7dfc(%rip), %rdi      # 0x132a4
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb4ef
movq -0x10(%rbp), %rsi
movl $0x13, %edi
callq 0x9d10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb500
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb4f9
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0xb4a1
nopl (%rax,%rax)