LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/codegen.c
// Function: store
void store(Type *ty) {
  if (is_struct(ty)) {
    fprintf(output, "\tpop  rsi\n");

    int size = sizeof_type(ty);
    int i = 0;
    while (i <= size - 8) {
      fprintf(output, "\tmov  rdi, QWORD PTR [rsi + %d]\n", i);
      fprintf(output, "\tmov  QWORD PTR [rax + %d], rdi\n", i);
      i += 8;
    }
    while (i < size) {
      fprintf(output, "\tmov  dil, BYTE PTR [rsi + %d]\n", i);
      fprintf(output, "\tmov  BYTE PTR [rax + %d], dil\n", i);
      i++;
    }
    fprintf(output, "\tpush rax\n");
  } else {
    fprintf(output, "\tpop  rdi\n");
    fprintf(output, "\tmov  [rax], %s\n", reg_rdi[reg_size(ty)]);
    fprintf(output, "\tpush rdi\n");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xaeb5
leaq 0x10a41(%rip), %r13     # 0x13220
movq (%r13), %rcx
testb %al, %al
je 0x288f
leaq 0x9c01(%rip), %rdi      # 0xc3f3
movl $0xa, %esi
movl $0x1, %edx
callq 0x1190
movq %rbx, %rdi
callq 0xafa3
movl %eax, %ebx
xorl %ebp, %ebp
cmpl $0x8, %eax
jl 0x284e
leal -0x8(%rbx), %r12d
leaq 0x9be1(%rip), %r14      # 0xc3fe
leaq 0x9bfb(%rip), %r15      # 0xc41f
xorl %ebp, %ebp
movq (%r13), %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10f0
movq (%r13), %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10f0
addl $0x8, %ebp
cmpl %r12d, %ebp
jle 0x2826
leaq 0x9ae4(%rip), %r14      # 0xc339
cmpl %ebx, %ebp
jge 0x28d6
leaq 0x9be0(%rip), %r15      # 0xc440
leaq 0x9bf9(%rip), %r12      # 0xc460
movq (%r13), %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10f0
movq (%r13), %rdi
movq %r12, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10f0
incl %ebp
cmpl %ebp, %ebx
jne 0x2867
jmp 0x28d6
leaq 0x9bea(%rip), %rdi      # 0xc480
movl $0xa, %esi
movl $0x1, %edx
callq 0x1190
movq (%r13), %r14
movq %rbx, %rdi
callq 0x1b36
cltq
leaq 0x10856(%rip), %rcx     # 0x13110
leaq (%rcx,%rax,4), %rdx
leaq 0x9bc6(%rip), %rsi      # 0xc48b
movq %r14, %rdi
xorl %eax, %eax
callq 0x10f0
leaq 0x9bc6(%rip), %r14      # 0xc49c
movq (%r13), %rcx
movl $0xa, %esi
movl $0x1, %edx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/codegen.c
// Function: gen_if
void gen_if(Node *node) {
  char *else_str = new_label();
  char *end_str = new_label();
  gen(node->lhs);
  fprintf(output, "\tpop  rax\n");
  fprintf(output, "\tcmp  rax, 0\n");
  fprintf(output, "\tje   %s\n", else_str);
  gen_stmt(node->rhs);
  emit_jmp(end_str);
  emit_label(else_str);
  gen_stmt(node->xhs);
  emit_label(end_str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1958
movq %rax, %r15
callq 0x1958
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x1ead
leaq 0x108fa(%rip), %r13     # 0x13220
movq (%r13), %rcx
leaq 0x9a1f(%rip), %rdi      # 0xc350
movl $0xa, %esi
movl $0x1, %edx
callq 0x1190
movq (%r13), %rcx
leaq 0x9b5c(%rip), %rdi      # 0xc4a7
movl $0xd, %esi
movl $0x1, %edx
callq 0x1190
movq (%r13), %rdi
leaq 0x9b50(%rip), %rsi      # 0xc4b5
movq %r15, %rdx
xorl %eax, %eax
callq 0x10f0
movq 0x10(%rbx), %rdi
callq 0x29c8
movq (%r13), %rdi
leaq 0x97fd(%rip), %rsi      # 0xc180
movq %r14, %rdx
xorl %eax, %eax
callq 0x10f0
movq (%r13), %rdi
leaq 0x97e3(%rip), %r12      # 0xc17b
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10f0
movq 0x18(%rbx), %rdi
callq 0x29c8
movq (%r13), %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/codegen.c
// Function: gen_while
void gen_while(Node *node) {
  push_loop();
  char *cond_str = get_continue(node->token);
  char *end_str = get_break(node->token);
  emit_label(cond_str);
  gen(node->lhs);
  fprintf(output, "\tpop  rax\n");
  fprintf(output, "\tcmp  rax, 0\n");
  fprintf(output, "\tje   %s\n", end_str);
  gen_stmt(node->rhs);
  emit_jmp(cond_str);
  emit_label(end_str);
  pop_loop();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1a20
cmpq $0x0, 0x107d4(%rip)     # 0x131f0
jne 0x2a30
movq 0x50(%rbx), %rdi
leaq 0x9788(%rip), %rsi      # 0xc1b1
xorl %eax, %eax
callq 0x52f9
movq 0x107b9(%rip), %rax     # 0x131f0
movq 0x8(%rax), %r14
testq %rax, %rax
jne 0x2a52
movq 0x50(%rbx), %rdi
leaq 0x979b(%rip), %rsi      # 0xc1e6
xorl %eax, %eax
callq 0x52f9
movq 0x10797(%rip), %rax     # 0x131f0
movq 0x10(%rax), %r15
leaq 0x107bc(%rip), %r13     # 0x13220
movq (%r13), %rdi
leaq 0x970c(%rip), %r12      # 0xc17b
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10f0
movq 0x8(%rbx), %rdi
callq 0x1ead
movq (%r13), %rcx
leaq 0x98c0(%rip), %rdi      # 0xc350
movl $0xa, %esi
movl $0x1, %edx
callq 0x1190
movq (%r13), %rcx
leaq 0x99fd(%rip), %rdi      # 0xc4a7
movl $0xd, %esi
movl $0x1, %edx
callq 0x1190
movq (%r13), %rdi
leaq 0x99f1(%rip), %rsi      # 0xc4b5
movq %r15, %rdx
xorl %eax, %eax
callq 0x10f0
movq 0x10(%rbx), %rdi
callq 0x29c8
movq (%r13), %rdi
leaq 0x969e(%rip), %rsi      # 0xc180
movq %r14, %rdx
xorl %eax, %eax
callq 0x10f0
movq (%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10f0
movq 0x106ec(%rip), %rax     # 0x131f0
movq (%rax), %rax
movq %rax, 0x106e2(%rip)     # 0x131f0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/codegen.c
// Function: gen_for
void gen_for(Node *node) {
  push_loop();
  char *loop_label = new_label();
  char *post_label = get_continue(node->token);
  char *end_label = get_break(node->token);
  gen(node->lhs);
  emit_label(loop_label);
  gen(node->rhs);
  fprintf(output, "\tpop  rax\n");
  fprintf(output, "\tcmp  rax, 0\n");
  fprintf(output, "\tje   %s\n", end_label);
  gen_stmt(node->nodes->data[0]);
  emit_label(post_label);
  gen(node->xhs);
  if (node->xhs) fprintf(output, "\tpop  rax\n");
  emit_jmp(loop_label);
  emit_label(end_label);
  pop_loop();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x1a20
callq 0x1958
movq %rax, %rbx
cmpq $0x0, 0x106b5(%rip)     # 0x131f0
jne 0x2b4f
movq 0x50(%r14), %rdi
leaq 0x9669(%rip), %rsi      # 0xc1b1
xorl %eax, %eax
callq 0x52f9
movq 0x1069a(%rip), %rax     # 0x131f0
movq 0x8(%rax), %r12
testq %rax, %rax
jne 0x2b71
movq 0x50(%r14), %rdi
leaq 0x967c(%rip), %rsi      # 0xc1e6
xorl %eax, %eax
callq 0x52f9
movq 0x10678(%rip), %rax     # 0x131f0
movq 0x10(%rax), %r15
movq 0x8(%r14), %rdi
callq 0x1ead
leaq 0x10694(%rip), %rbp     # 0x13220
movq (%rbp), %rdi
leaq 0x95e4(%rip), %r13      # 0xc17b
movq %r13, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10f0
movq 0x10(%r14), %rdi
callq 0x1ead
movq (%rbp), %rcx
leaq 0x9798(%rip), %rdi      # 0xc350
movl $0xa, %esi
movl $0x1, %edx
callq 0x1190
movq (%rbp), %rcx
leaq 0x98d5(%rip), %rdi      # 0xc4a7
movl $0xd, %esi
movl $0x1, %edx
callq 0x1190
movq (%rbp), %rdi
leaq 0x98c9(%rip), %rsi      # 0xc4b5
movq %r15, %rdx
xorl %eax, %eax
callq 0x10f0
movq 0x48(%r14), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x29c8
movq (%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x10f0
movq 0x18(%r14), %rdi
callq 0x1ead
cmpq $0x0, 0x18(%r14)
je 0x2c40
movq (%rbp), %rcx
leaq 0x971f(%rip), %rdi      # 0xc350
movl $0xa, %esi
movl $0x1, %edx
callq 0x1190
movq (%rbp), %rdi
leaq 0x9535(%rip), %rsi      # 0xc180
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10f0
movq (%rbp), %rdi
leaq 0x951b(%rip), %rsi      # 0xc17b
movq %r15, %rdx
xorl %eax, %eax
callq 0x10f0
movq 0x1057f(%rip), %rax     # 0x131f0
movq (%rax), %rax
movq %rax, 0x10575(%rip)     # 0x131f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/codegen.c
// Function: gen_block
void gen_block(Node *node) {
  if (!node) return;
  Vector *vec = node->nodes;
  int len = vec_len(vec);
  for (int i = 0; i < len; i++) gen_stmt(vec->data[i]);
}

// Assembly:
testq %rdi, %rdi
je 0x2cc3
pushq %r15
pushq %r14
pushq %rbx
movq 0x48(%rdi), %rbx
movq %rbx, %rdi
callq 0x3f62
testl %eax, %eax
jle 0x2cbe
movl %eax, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x29c8
incq %r15
cmpq %r15, %r14
jne 0x2caa
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/codegen.c
// Function: builtin_va_start
void builtin_va_start(Node *node) {
  // void va_start(va_list ap, parmN);
  // typedef struct {
  //  int gp_offset;
  //  int fp_offset;
  //  void *overflow_arg_area;
  //  void *reg_save_area;
  //} va_list[1];
  int gp = vec_len(node->nodes);
  int fp = 0;
  // rdi = ap
  // ap->gp_offset = gp * 8
  fprintf(output, "\tmov  DWORD PTR [rdi], %d\n", gp * 8);
  // ap->fp_offset = 48 + fp * 8
  fprintf(output, "\tmov  DWORD PTR [rdi + 4], %d\n", 48 + fp * 8);
  // ap->reg_save_area = rbp - 128 (address for first arg(rdi))
  fprintf(output, "\tmov  [rdi + 16], rbp\n");
  fprintf(output, "\tsub  QWORD PTR [rdi + 16], 128\n");
  // this is dummy.
  fprintf(output, "\tpush rax\n");
  return;
}

// Assembly:
pushq %rbx
movq 0x48(%rdi), %rdi
callq 0x3f62
leaq 0x1054b(%rip), %rbx     # 0x13220
movq (%rbx), %rdi
leal (,%rax,8), %edx
leaq 0x97d9(%rip), %rsi      # 0xc4bf
xorl %eax, %eax
callq 0x10f0
movq (%rbx), %rdi
leaq 0x97e3(%rip), %rsi      # 0xc4da
movl $0x30, %edx
xorl %eax, %eax
callq 0x10f0
movq (%rbx), %rcx
leaq 0x97ec(%rip), %rdi      # 0xc4f9
movl $0x16, %esi
movl $0x1, %edx
callq 0x1190
movq (%rbx), %rcx
leaq 0x97ea(%rip), %rdi      # 0xc510
movl $0x20, %esi
movl $0x1, %edx
callq 0x1190
movq (%rbx), %rcx
leaq 0x95fa(%rip), %rdi      # 0xc339
movl $0xa, %esi
movl $0x1, %edx
popq %rbx
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/codegen.c
// Function: gen_lnot
void gen_lnot(Node *node) {
  Type *l_ty = type(node->lhs);
  int reg_mode;
  char *false_label = new_label();
  char *exit_label = new_label();
  gen(node->lhs);

  if (!is_arith(l_ty) && !is_ptr(l_ty))
    error_at_node(node->lhs, "Illegal operation. (Type mismatch)");

  reg_mode = reg_size(l_ty);
  fprintf(output, "\tpop  rax\n");
  fprintf(output, "\tcmp  %s, 0\n", reg_rax[reg_mode]);
  fprintf(output, "\tjne  %s\n", false_label);

  fprintf(output, "\tmov  rax, 1\n");
  emit_jmp(exit_label);

  emit_label(false_label);
  fprintf(output, "\tmov  rax, 0\n");
  emit_label(exit_label);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r12
movq 0x8(%rdi), %rdi
callq 0xb354
movq %rax, %r15
callq 0x1958
movq %rax, %r14
callq 0x1958
movq %rax, %rbx
movq 0x8(%r12), %rdi
callq 0x1ead
movq %r15, %rdi
callq 0xaef0
testb %al, %al
jne 0x3667
movq %r15, %rdi
callq 0xaea0
testb %al, %al
jne 0x3667
movq 0x8(%r12), %rdi
leaq 0x9123(%rip), %rsi      # 0xc783
xorl %eax, %eax
callq 0x552e
movq %r15, %rdi
callq 0x1b36
movl %eax, %ebp
leaq 0xfba8(%rip), %r12      # 0x13220
movq (%r12), %rcx
leaq 0x8ccd(%rip), %rdi      # 0xc350
movl $0xa, %esi
movl $0x1, %edx
callq 0x1190
movq (%r12), %rdi
movslq %ebp, %rax
leaq 0xfa60(%rip), %rcx      # 0x13100
leaq (%rcx,%rax,4), %rdx
leaq 0x90fb(%rip), %rsi      # 0xc7a6
xorl %eax, %eax
callq 0x10f0
movq (%r12), %rdi
leaq 0x9104(%rip), %rsi      # 0xc7c1
movq %r14, %rdx
xorl %eax, %eax
callq 0x10f0
movq (%r12), %rcx
leaq 0x90e1(%rip), %rdi      # 0xc7b3
movl $0xd, %esi
movl $0x1, %edx
callq 0x1190
movq (%r12), %rdi
leaq 0x8a94(%rip), %rsi      # 0xc180
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10f0
movq (%r12), %rdi
leaq 0x8a7a(%rip), %r15      # 0xc17b
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10f0
movq (%r12), %rcx
leaq 0x8e8d(%rip), %rdi      # 0xc5a6
movl $0xd, %esi
movl $0x1, %edx
callq 0x1190
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/codegen.c
// Function: gen_initialize
void gen_initialize(Type *l_ty, int offset, Node *rhs) {
  if (is_array(l_ty) && is_array(type(rhs))) {
    Vector *vec = rhs->nodes;
    Type *ty = l_ty->ptr_to;
    int size = l_ty->array_size;
    for (int i = 0; i < vec_len(vec); i++) {
      if (size <= i) break;
      if (vec->data[i]->kind == ND_INIT) {
        gen_initialize(ty, offset, vec->data[i]);
      } else {
        gen(vec->data[i]);
        fprintf(output, "\tlea  rax, [rbp - %d]\n", offset);
        store(ty);
      }
      offset -= sizeof_type(ty);
    }
  } else if (is_struct(l_ty) && is_struct(type(rhs))) {
    Vector *vec = rhs->nodes;
    MemberInfo *member = l_ty->member;
    for (int i = 0; i < vec_len(vec); i++) {
      if (vec->data[i]->kind == ND_INIT) {
        gen_initialize(member->type, offset - member->offset, vec->data[i]);
      } else {
        gen(vec->data[i]);
        fprintf(output, "\tlea  rax, [rbp - %d]\n", offset - member->offset);
        store(member->type);
      }
      member = member->next;
    }
  } else {
    error_at_node(rhs, "Unsupported initializer.");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r12
callq 0xaea7
testb %al, %al
je 0x3841
movq %r14, %rdi
callq 0xb354
movq %rax, %rdi
callq 0xaea7
testb %al, %al
je 0x3841
movq 0x48(%r14), %r14
movq 0x8(%r12), %r15
movl 0x10(%r12), %ebp
movq %r14, %rdi
callq 0x3f62
testl %eax, %eax
setg %al
testl %ebp, %ebp
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x38ea
movl %ebp, %r13d
movl $0x1, %r12d
movq (%r14), %rax
movq -0x8(%rax,%r12,8), %rdx
cmpl $0x3, (%rdx)
jne 0x37e6
movq %r15, %rdi
movl %ebx, %esi
callq 0x3761
jmp 0x3810
movq %rdx, %rdi
callq 0x1ead
leaq 0xfa2b(%rip), %rax      # 0x13220
movq (%rax), %rdi
leaq 0x8b8a(%rip), %rsi      # 0xc389
movl %ebx, %edx
xorl %eax, %eax
callq 0x10f0
movq %r15, %rdi
callq 0x27c5
movq %r15, %rdi
callq 0xafa3
movl %eax, %ebp
movq %r14, %rdi
callq 0x3f62
cltq
cmpq %rax, %r12
jge 0x38ea
subl %ebp, %ebx
leaq 0x1(%r12), %rax
cmpq %r13, %r12
movq %rax, %r12
jb 0x37cd
jmp 0x38ea
movq %r12, %rdi
callq 0xaeb5
testb %al, %al
je 0x38f9
movq %r14, %rdi
callq 0xb354
movq %rax, %rdi
callq 0xaeb5
testb %al, %al
je 0x38f9
movq 0x48(%r14), %r14
movq 0x20(%r12), %r12
movq %r14, %rdi
callq 0x3f62
testl %eax, %eax
jle 0x38ea
leaq 0xf99b(%rip), %r13      # 0x13220
leaq 0x8afd(%rip), %r15      # 0xc389
xorl %ebp, %ebp
movq (%r14), %rax
movq (%rax,%rbp,8), %rdx
cmpl $0x3, (%rdx)
jne 0x38ad
movq 0x10(%r12), %rdi
movl %ebx, %esi
subl 0x18(%r12), %esi
callq 0x3761
jmp 0x38d4
movq %rdx, %rdi
callq 0x1ead
movq (%r13), %rdi
movl %ebx, %edx
subl 0x18(%r12), %edx
movq %r15, %rsi
xorl %eax, %eax
callq 0x10f0
movq 0x10(%r12), %rdi
callq 0x27c5
incq %rbp
movq (%r12), %r12
movq %r14, %rdi
callq 0x3f62
cltq
cmpq %rax, %rbp
jl 0x388e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9eae(%rip), %rsi      # 0xd7ae
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x552e
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/codegen.c
// Function: eval_const
Node *eval_const(Node *node) {
  long res;
  switch (node->kind) {
    case ND_NUM:
      return node;
    case ND_ADD:
      res = eval_const(node->lhs)->num_val + eval_const(node->rhs)->num_val;
      return new_node_num(res, NULL);
    case ND_SUB:
      res = eval_const(node->lhs)->num_val - eval_const(node->rhs)->num_val;
      return new_node_num(res, NULL);
    case ND_MUL:
      res = eval_const(node->lhs)->num_val * eval_const(node->rhs)->num_val;
      return new_node_num(res, NULL);
    default:
      if (node->kind != ND_NUM)
        error_at_node(node,
                      "Calculation in an initializer is not supported yet.");
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
decl %eax
cmpl $0x5, %eax
ja 0x3b64
leaq 0x860d(%rip), %rcx      # 0xc104
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
callq 0x3ae0
movq 0x20(%rax), %r14
movq 0x10(%rbx), %rdi
callq 0x3ae0
addq 0x20(%rax), %r14
jmp 0x3b53
movq 0x8(%rbx), %rdi
callq 0x3ae0
movq 0x20(%rax), %r14
movq 0x10(%rbx), %rdi
callq 0x3ae0
subq 0x20(%rax), %r14
jmp 0x3b53
movq 0x8(%rbx), %rdi
callq 0x3ae0
movq 0x20(%rax), %r14
movq 0x10(%rbx), %rdi
callq 0x3ae0
imulq 0x20(%rax), %r14
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x58ac
leaq 0x8e93(%rip), %rsi      # 0xc9fe
movq %rbx, %rdi
xorl %eax, %eax
callq 0x552e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/container.c
// Function: vec_new
Vector *vec_new() {
  Vector *vec = (Vector *)malloc(sizeof(Vector));
  vec->data = (Node **)malloc(5 * sizeof(void *));
  vec->len = 0;
  vec->capacity = 5;
  return vec;
}

// Assembly:
pushq %rbx
movl $0x10, %edi
callq 0x1110
movq %rax, %rbx
movl $0x28, %edi
callq 0x1110
movq %rax, (%rbx)
movabsq $0x500000000, %rax      # imm = 0x500000000
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/container.c
// Function: vec_push
void vec_push(Vector *vec, Node *data) {
  if (vec->len == vec->capacity) {
    vec->capacity *= 2;
    vec->data = realloc(vec->data, vec->capacity * sizeof(void *));
  }
  vec->data[vec->len++] = data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0xc(%rdi), %rsi
cmpl %esi, 0x8(%rdi)
jne 0x3f8f
leal (%rsi,%rsi), %eax
movl %eax, 0xc(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x1140
movq %rax, (%r14)
movq (%r14), %rax
movslq 0x8(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%r14)
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/debug.c
// Function: print_tokens
void print_tokens(FILE *stream, Token *token) {
  fprintf(stream, "// ");
  while (token) {
    print_token(stream, token);
    if (token->kind == TK_SEMI) fprintf(stream, "\n// ");
    token = token->next;
  }
  fprintf(stream, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8cc6(%rip), %rdi      # 0xcd17
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
testq %r14, %r14
je 0x409e
leaq 0x8ca7(%rip), %r15      # 0xcd16
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fac
cmpl $0x1c, (%r14)
jne 0x4095
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1190
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x406f
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/debug.c
// Function: print_nodes
void print_nodes() {
  int len = vec_len(ext_declarations);
  for (int i = 0; i < len; i++) {
    Node *node = ext_declarations->data[i];
    fprintf(output, "// ");
    print_node(node);
    fprintf(output, "\n");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xe765(%rip), %r15      # 0x13238
movq (%r15), %rdi
callq 0x3f62
testl %eax, %eax
jle 0x4b31
movl %eax, %r12d
xorl %r13d, %r13d
leaq 0xe734(%rip), %rbp      # 0x13220
leaq 0x8224(%rip), %rbx      # 0xcd17
movq (%r15), %rax
movq (%rax), %rax
movq (%rax,%r13,8), %r14
movq (%rbp), %rcx
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1190
movq %r14, %rdi
callq 0x40b0
movq (%rbp), %rsi
movl $0xa, %edi
callq 0x10c0
incq %r13
cmpq %r13, %r12
jne 0x4af3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/debug.c
// Function: print_struct_member
void print_struct_member(FILE *stream, MemberInfo *member) {
  bool first = true;
  while (member) {
    if (!first) fprintf(stream, ", ");
    first = false;
    print_type(stream, member->type);
    if (member->ident)
      fprintf(stream, "<%.*s:%d>", member->ident->len, member->ident->str,
              member->offset);
    else
      fprintf(stream, "<>");
    member = member->next;
  }
}

// Assembly:
testq %rsi, %rsi
je 0x4bdf
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, %al
leaq 0x83c9(%rip), %r15      # 0xcf2a
leaq 0x83b8(%rip), %r12      # 0xcf20
leaq 0x8352(%rip), %r13      # 0xcec1
testb $0x1, %al
jne 0x4b88
movl $0x2, %esi
movl $0x1, %edx
movq %r13, %rdi
movq %r14, %rcx
callq 0x1190
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x477f
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x4bb7
movl 0x28(%rax), %edx
movq 0x20(%rax), %rcx
movl 0x18(%rbx), %r8d
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x10f0
jmp 0x4bcc
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x1190
movq (%rbx), %rbx
xorl %eax, %eax
testq %rbx, %rbx
jne 0x4b6f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/debug.c
// Function: print_enum_member
void print_enum_member(MemberInfo *member) {
  bool first = true;
  while (member) {
    if (!first) fprintf(output, ", ");
    first = false;
    print_type(output, member->type);
    member = member->next;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x4c31
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, %al
leaq 0xe62a(%rip), %r15      # 0x13220
leaq 0x82c4(%rip), %r14      # 0xcec1
testb $0x1, %al
jne 0x4c16
movq (%r15), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x1190
movq (%r15), %rdi
movq 0x10(%rbx), %rsi
callq 0x477f
movq (%rbx), %rbx
xorl %eax, %eax
testq %rbx, %rbx
jne 0x4bfd
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/debug.c
// Function: print_locals
void print_locals() {
  LVar *var = locals;
  while (var) {
    fprintf(output, "//    %.*s  offset:%d  ", var->token->len, var->token->str,
            var->offset);
    print_type(output, var->type);
    fprintf(output, "\n");
    var = var->next;
  }
  fprintf(output, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xe60a(%rip), %rax      # 0x13248
movq (%rax), %r14
testq %r14, %r14
je 0x4c91
leaq 0xe5d3(%rip), %r15      # 0x13220
leaq 0x82d9(%rip), %rbx      # 0xcf2d
movq (%r15), %rdi
movq 0x8(%r14), %rax
movl 0x28(%rax), %edx
movq 0x20(%rax), %rcx
movl 0x18(%r14), %r8d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rdi
movq 0x10(%r14), %rsi
callq 0x477f
movq (%r15), %rsi
movl $0xa, %edi
callq 0x10c0
movq (%r14), %r14
testq %r14, %r14
jne 0x4c54
leaq 0xe588(%rip), %rax      # 0x13220
movq (%rax), %rsi
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/debug.c
// Function: print_globals
void print_globals() {
  Global *global = globals;
  fprintf(output, "// Globals\n");
  while (global) {
    fprintf(output, "// %.*s ", global->token->len, global->token->str);
    print_type(output, global->type);
    print_node(global->body);
    fprintf(output, "\n");
    global = global->next;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xe57a(%rip), %rax      # 0x13230
movq (%rax), %r14
leaq 0xe560(%rip), %r15      # 0x13220
movq (%r15), %rcx
leaq 0x827b(%rip), %rdi      # 0xcf45
movl $0xb, %esi
movl $0x1, %edx
callq 0x1190
testq %r14, %r14
je 0x4d27
leaq 0x826c(%rip), %rbx      # 0xcf51
movq (%r15), %rdi
movq 0x8(%r14), %rax
movl 0x28(%rax), %edx
movq 0x20(%rax), %rcx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rdi
movq 0x10(%r14), %rsi
callq 0x477f
movq 0x18(%r14), %rdi
callq 0x40b0
movq (%r15), %rsi
movl $0xa, %edi
callq 0x10c0
movq (%r14), %r14
testq %r14, %r14
jne 0x4ce5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/debug.c
// Function: print_funcs
void print_funcs() {
  Function *func = functions;
  fprintf(output, "// Functions\n");
  while (func) {
    fprintf(output, "// %.*s ", func->token->len, func->token->str);
    print_type(output, func->type);
    fprintf(output, "\n");
    func = func->next;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xe52f(%rip), %rax      # 0x13268
movq (%rax), %r14
leaq 0xe4dd(%rip), %r15      # 0x13220
movq (%r15), %rcx
leaq 0x820d(%rip), %rdi      # 0xcf5a
movl $0xd, %esi
movl $0x1, %edx
callq 0x1190
testq %r14, %r14
je 0x4da1
leaq 0x81e9(%rip), %rbx      # 0xcf51
movq (%r15), %rdi
movq 0x8(%r14), %rax
movl 0x28(%rax), %edx
movq 0x20(%rax), %rcx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rdi
movq 0x10(%r14), %rsi
callq 0x477f
movq (%r15), %rsi
movl $0xa, %edi
callq 0x10c0
movq (%r14), %r14
testq %r14, %r14
jne 0x4d68
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/debug.c
// Function: print_strings
void print_strings() {
  fprintf(output, "// Strings\n");
  int i = 0;
  while (i < vec_len(strings)) {
    Token *t = strings->data[i]->token;
    fprintf(output, "// \"");
    for (; t; t = t->next) fprintf(output, "%.*s", t->len, t->str);
    fprintf(output, "\"\n");
    i++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xe467(%rip), %r12      # 0x13220
movq (%r12), %rcx
leaq 0x81a4(%rip), %rdi      # 0xcf68
movl $0xb, %esi
movl $0x1, %edx
callq 0x1190
leaq 0xe43e(%rip), %r13      # 0x13218
movq (%r13), %rdi
callq 0x3f62
testl %eax, %eax
jle 0x4e6d
leaq 0x8344(%rip), %r14      # 0xd136
leaq 0x7c9f(%rip), %r15      # 0xca98
xorl %ebp, %ebp
movq (%r13), %rax
movq (%rax), %rax
movq (%rax,%rbp,8), %rax
movq 0x50(%rax), %rbx
movq (%r12), %rcx
movl $0x4, %esi
movl $0x1, %edx
leaq 0x8155(%rip), %rdi      # 0xcf74
callq 0x1190
testq %rbx, %rbx
je 0x4e44
movq (%r12), %rdi
movl 0x28(%rbx), %edx
movq 0x20(%rbx), %rcx
movq %r15, %rsi
xorl %eax, %eax
callq 0x10f0
movq 0x8(%rbx), %rbx
jmp 0x4e24
movq (%r12), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x1190
incq %rbp
movq (%r13), %rdi
callq 0x3f62
cltq
cmpq %rax, %rbp
jl 0x4dfb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/debug.c
// Function: print_structs
void print_structs() {
  TagName *tag = tagnames;
  fprintf(output, "\n// Tagnames\n");
  while (tag) {
    if (tag->ident)
      fprintf(output, "// %.*s ", tag->ident->len, tag->ident->str);
    else
      fprintf(output, "// anonymus ");
    if (is_struct(tag->type)) {
      fprintf(output, "struct { ");
      print_struct_member(output, tag->type->member);
      fprintf(output, "}\n");
    } else if (is_enum(tag->type)) {
      fprintf(output, "enum { ");
      print_enum_member(tag->type->member);
      fprintf(output, "}\n");
    } else if (is_enum_el(tag->type)) {
      fprintf(output, "enum_el { %d }\n", tag->type->offset);
    }
    tag = tag->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xe3ca(%rip), %rax      # 0x13258
movq (%rax), %r13
leaq 0xe388(%rip), %r12      # 0x13220
movq (%r12), %rcx
leaq 0x80d6(%rip), %rdi      # 0xcf79
movl $0xd, %esi
movl $0x1, %edx
callq 0x1190
testq %r13, %r13
je 0x4fc6
leaq 0x80c5(%rip), %rbx      # 0xcf87
leaq 0x80cb(%rip), %r14      # 0xcf94
leaq 0x80e3(%rip), %r15      # 0xcfb3
leaq 0x807a(%rip), %rbp      # 0xcf51
movq 0x8(%r13), %rcx
movq (%r12), %rax
testq %rcx, %rcx
je 0x4efa
movl 0x28(%rcx), %edx
movq 0x20(%rcx), %rcx
movq %rax, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10f0
jmp 0x4f0f
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x1190
movq 0x10(%r13), %rdi
callq 0xaeb5
testb %al, %al
je 0x4f45
movq (%r12), %rcx
movl $0x9, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x1190
movq (%r12), %rdi
movq 0x10(%r13), %rax
movq 0x20(%rax), %rsi
callq 0x4b40
jmp 0x4f79
movq 0x10(%r13), %rdi
callq 0xaebc
testb %al, %al
je 0x4f9e
movq (%r12), %rcx
movl $0x7, %esi
movl $0x1, %edx
leaq 0x8037(%rip), %rdi      # 0xcf9e
callq 0x1190
movq 0x10(%r13), %rax
movq 0x20(%rax), %rdi
callq 0x4be0
movq (%r12), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
callq 0x1190
movq (%r13), %r13
testq %r13, %r13
jne 0x4ed7
jmp 0x4fc6
movq 0x10(%r13), %rdi
callq 0xaec3
testb %al, %al
je 0x4f8f
movq (%r12), %rdi
movq 0x10(%r13), %rax
movl 0x28(%rax), %edx
leaq 0x7fe9(%rip), %rsi      # 0xcfa6
xorl %eax, %eax
callq 0x10f0
jmp 0x4f8f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/debug.c
// Function: print_typedefs
void print_typedefs() {
  fprintf(output, "\n// Typedef\n");
  Typedef *tdef = tdef_names;
  while (tdef) {
    fprintf(output, "// %.*s ", tdef->ident->len, tdef->ident->str);
    print_type(output, tdef->type);
    fprintf(output, "\n");
    tdef = tdef->next;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xe23f(%rip), %r14      # 0x13220
movq (%r14), %rcx
leaq 0x7fcb(%rip), %rdi      # 0xcfb6
movl $0xc, %esi
movl $0x1, %edx
callq 0x1190
leaq 0xe25f(%rip), %rax      # 0x13260
movq (%rax), %r15
testq %r15, %r15
je 0x5049
leaq 0x7f41(%rip), %rbx      # 0xcf51
movq (%r14), %rdi
movq 0x10(%r15), %rax
movl 0x28(%rax), %edx
movq 0x20(%rax), %rcx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10f0
movq (%r14), %rdi
movq 0x8(%r15), %rsi
callq 0x477f
movq (%r14), %rsi
movl $0xa, %edi
callq 0x10c0
movq (%r15), %r15
testq %r15, %r15
jne 0x5010
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/error.c
// Function: get_line
int get_line(char *p, char *source) {
  char *cursor;
  int line = 1;
  if (p < source) error("Illegal position in source.");
  while (cursor = strchr(source, '\n')) {
    if (cursor > p) break;
    source = cursor + 1;
    line++;
  }
  return line;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
jb 0x50a2
movq %rdi, %rbx
movq %rsi, %rdi
movl $0xa, %esi
callq 0x10a0
testq %rax, %rax
sete %cl
cmpq %rbx, %rax
seta %dl
orb %cl, %dl
movl $0x1, %ebp
jne 0x5099
incq %rax
incl %ebp
movq %rax, %rdi
movl $0xa, %esi
callq 0x10a0
testq %rax, %rax
je 0x5099
cmpq %rbx, %rax
jbe 0x507d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7f1a(%rip), %rdi      # 0xcfc3
xorl %eax, %eax
callq 0x50b0
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/error.c
// Function: get_pos
PosInfo *get_pos(char *p, char *source) {
  char *cursor;
  int line = 1;
  while (cursor = strchr(source, '\n')) {
    if (cursor > p) break;
    source = cursor + 1;
    line++;
  }
  if (!cursor) cursor = strchr(p, '\0');

  PosInfo *pos = calloc(1, sizeof(PosInfo));
  pos->line = line;
  pos->pos_in_line = (int)(p - source);
  pos->line_start = source;
  pos->line_len = (int)(cursor - source);
  return pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0xa, %esi
callq 0x10a0
movq %rax, %r15
testq %rax, %rax
sete %al
cmpq %rbx, %r15
seta %cl
orb %al, %cl
movl $0x1, %ebp
jne 0x51af
movq %r15, %r14
incq %r14
incl %ebp
movq %r14, %rdi
movl $0xa, %esi
callq 0x10a0
movq %rax, %r15
testq %rax, %rax
sete %al
je 0x51af
cmpq %rbx, %r15
jbe 0x518a
testb %al, %al
je 0x51c1
movq %rbx, %rdi
callq 0x1090
movq %rax, %r15
addq %rbx, %r15
movl $0x1, %edi
movl $0x18, %esi
callq 0x10d0
movl %ebp, (%rax)
subl %r14d, %ebx
movl %ebx, 0x4(%rax)
movq %r14, 0x8(%rax)
subl %r14d, %r15d
movl %r15d, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/error.c
// Function: error_at_char
void error_at_char(FileInfo *fi, char *err_char, char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);

  PosInfo *pos = get_pos(err_char, fi->start);
  print_error_line(fi, pos, 1);
  vfprintf(stderr, fmt, ap);
  fprintf(stderr, "\n");
  exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x20(%rsp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x5291
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r15
movq %rsi, 0x10(%r15)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%r15)
movq 0x10(%rdi), %rsi
movq %rdx, %rdi
callq 0x5158
movq %r14, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x129b
movq 0xdd24(%rip), %r14      # 0x12ff8
movq (%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1160
movq (%r14), %rsi
movl $0xa, %edi
callq 0x10c0
movl $0x1, %edi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/error.c
// Function: error_at_token
void error_at_token(Token *token, char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);

  FileInfo *fi = get_file_info(token->str);
  PosInfo *pos = get_pos(token->str, fi->start);

  print_error_line(fi, pos, token->len);
  vfprintf(stderr, fmt, ap);
  fprintf(stderr, "\n");
  exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x535d
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rsi, 0x10(%r14)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
movq 0x20(%rdi), %rdi
callq 0x51ee
movq %rax, %r12
movq 0x20(%r15), %rdi
movq 0x10(%rax), %rsi
callq 0x5158
movl 0x28(%r15), %edx
movq %r12, %rdi
movq %rax, %rsi
callq 0x129b
movq 0xdc4c(%rip), %r15      # 0x12ff8
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1160
movq (%r15), %rsi
movl $0xa, %edi
callq 0x10c0
movl $0x1, %edi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/error.c
// Function: new_span
Span *new_span(Token *token) {
  char *start = token->str;
  Span *span = calloc(1, sizeof(Span));
  span->start = start;
  span->end = start + token->len;
  return span;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x10d0
movq %r14, (%rax)
movslq 0x28(%rbx), %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/error.c
// Function: merge_span
void merge_span(Span *span1, Span *span2) {
  if (!span1 || !span2) {
    fprintf(stderr, "null span\n");
    return;
  }
  // fprintf(stderr, "merge (%d:%d) (%d:%d)\n", span1->start, span1->end,
  //       span2->start, span2->end);
  if (span2->start < span1->start) span1->start = span2->start;
  if (span1->end < span2->end) span1->end = span2->end;
  return;
}

// Assembly:
testq %rdi, %rdi
je 0x5425
testq %rsi, %rsi
je 0x5425
movq (%rsi), %rax
cmpq (%rdi), %rax
jae 0x5416
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
cmpq %rax, 0x8(%rdi)
jae 0x5424
movq %rax, 0x8(%rdi)
retq
pushq %rax
callq 0x130a
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/error.c
// Function: get_node_span
Span *get_node_span(Node *node) {
  Span *span;
  // print_node(node);
  switch (node->kind) {
    case ND_IDENT:
    case ND_NUM:
    case ND_LVAR:
    case ND_GVAR:
    case ND_STR:
    case ND_INIT:
      span = new_span(node->token);
      break;
    case ND_ADD:
    case ND_SUB:
    case ND_MUL:
    case ND_DIV:
    case ND_EQ:
    case ND_NEQ:
    case ND_GE:
    case ND_GT:

    case ND_LAND:
    case ND_LOR:
    case ND_NOT:
    case ND_AND:
    case ND_OR:
    case ND_XOR:
    case ND_SHR:
    case ND_SHL:

    case ND_ASSIGN:
      span = new_span(node->token);
      merge_span(span, get_node_span(node->lhs));
      merge_span(span, get_node_span(node->rhs));
      break;
    case ND_ADDR:
    case ND_DEREF:
    case ND_MEMBER:
    case ND_CALL:
    case ND_CAST:
      span = new_span(node->token);
      merge_span(span, get_node_span(node->lhs));
      break;
    default:
      fprintf(stderr, "node span is not determined for this Node type.\n");
      span = new_span(node->token);
  }
  // fprintf(stderr, "span (%d:%d)\n", span->start, span->end);
  return span;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x1c, %eax
ja 0x551b
movl $0x2ffff0, %ecx         # imm = 0x2FFFF0
btl %eax, %ecx
jae 0x5492
movq 0x50(%r14), %r15
movq 0x20(%r15), %r12
movl $0x1, %edi
movl $0x10, %esi
callq 0x10d0
movq %rax, %rbx
movq %r12, (%rax)
movslq 0x28(%r15), %rax
addq %r12, %rax
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rdi
callq 0x5430
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5401
movq 0x10(%r14), %rdi
jmp 0x54fc
movl $0x300000f, %ecx        # imm = 0x300000F
btl %eax, %ecx
jae 0x54c6
movq 0x50(%r14), %r14
movq 0x20(%r14), %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x10d0
movq %rax, %rbx
movq %r15, (%rax)
movslq 0x28(%r14), %rax
addq %r15, %rax
movq %rax, 0x8(%rbx)
jmp 0x550c
movl $0x1cc00000, %ecx       # imm = 0x1CC00000
btl %eax, %ecx
jae 0x551b
movq 0x50(%r14), %r15
movq 0x20(%r15), %r12
movl $0x1, %edi
movl $0x10, %esi
callq 0x10d0
movq %rax, %rbx
movq %r12, (%rax)
movslq 0x28(%r15), %rax
addq %r12, %rax
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rdi
callq 0x5430
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5401
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1326
movq (%rbx), %rbx
jmp 0x550c
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/error.c
// Function: error_at_node
void error_at_node(Node *node, char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);

  Span *span = get_node_span(node);
  FileInfo *fi = get_file_info(span->start);
  PosInfo *pos = get_pos(span->start, fi->start);

  print_error_line(fi, pos, (int)(span->end - span->start));
  vfprintf(stderr, fmt, ap);
  fprintf(stderr, "\n");
  exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x558f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rsi, 0x10(%r14)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
callq 0x5430
movq %rax, %r15
movq (%rax), %rdi
callq 0x51ee
movq %rax, %r12
movq (%r15), %rdi
movq 0x10(%rax), %rsi
callq 0x5158
movl 0x8(%r15), %edx
subl (%r15), %edx
movq %r12, %rdi
movq %rax, %rsi
callq 0x129b
movq 0xda11(%rip), %r15      # 0x12ff8
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1160
movq (%r15), %rsi
movl $0xa, %edi
callq 0x10c0
movl $0x1, %edi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/monocc.c
// Function: read_file
char *read_file(char *path) {
  FILE *fp = fopen(path, "r");
  if (!fp) error("cannot open %s: %s\n", path, strerror(errno));

  if (fseek(fp, 0, SEEK_END) == -1)
    error("%s: fseek: %s\n", path, strerror(errno));
  size_t size = ftell(fp);
  if (fseek(fp, 0, SEEK_SET) == -1)
    error("%s: fseek: %s\n", path, strerror(errno));

  char *buf = calloc(1, size + 8);
  fread(buf, size, 1, fp);

  if (size == 0 || buf[size - 1] != '\n') buf[size++] = '\n';
  buf[size] = '\0';
  fclose(fp);
  // fprintf(stderr, "monocc: file read\n");
  // fprintf(stderr, "%s", buf);
  return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8399(%rip), %rsi      # 0xd9b4
callq 0x1150
movq %rax, %rbx
testq %rax, %rax
jne 0x5648
callq 0x1030
movl (%rax), %edi
callq 0x11a0
leaq 0x7a8f(%rip), %rdi      # 0xd0ca
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x50b0
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1130
cmpl $-0x1, %eax
jne 0x567c
callq 0x1030
movl (%rax), %edi
callq 0x11a0
leaq 0x7a6f(%rip), %rdi      # 0xd0de
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x50b0
movq %rbx, %rdi
callq 0x1100
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1130
cmpl $-0x1, %eax
jne 0x56b8
callq 0x1030
movl (%rax), %edi
callq 0x11a0
leaq 0x7a33(%rip), %rdi      # 0xd0de
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x50b0
leaq 0x8(%r15), %rsi
movl $0x1, %edi
callq 0x10d0
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x1070
testq %r15, %r15
je 0x56e9
cmpb $0xa, -0x1(%r14,%r15)
je 0x56f1
movb $0xa, (%r14,%r15)
incq %r15
movb $0x0, (%r14,%r15)
movq %rbx, %rdi
callq 0x1080
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/monocc.c
// Function: create_token
Token *create_token(TokenKind kind, char *str, int len) {
  Token *new_token = calloc(1, sizeof(Token));
  new_token->kind = kind;
  new_token->str = str;
  new_token->len = len;
  return new_token;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %ebp
movl $0x1, %edi
movl $0x30, %esi
callq 0x10d0
movl %ebp, (%rax)
movq %r14, 0x20(%rax)
movl %ebx, 0x28(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/monocc.c
// Function: main
int main(int argc, char **argv) {
  char *file;
  verbose = true;
  for (int i = 1; i < argc; i++) {
    if (strcmp(argv[i], "-test") == 0) {
      test_vec();
      return 0;
    } else if (strcmp(argv[i], "-string") == 0) {
      if (i + 2 > argc) {
        fprintf(stderr, "No input string.\n");
        return 1;
      }
      file = "input";
      source_text = argv[i + 1];
      output = fopen("tmp.s", "w");
      compile(file);
      return 0;
    } else if (strcmp(argv[i], "-v") == 0) {
      verbose = false;
    } else {
      file = argv[i];
      source_text = read_file(argv[i]);
      output_file_name = calloc(1, strlen(file) + 5);
      strcpy(output_file_name, file);
      char *dot = output_file_name + strlen(output_file_name) - 2;
      if (strcmp(dot, ".c") != 0) {
        fprintf(stderr, "Invalid aource file name.");
        return 1;
      }
      *(dot + 1) = 's';

      output = fopen(output_file_name, "w");
      if (!output) {
        fprintf(stderr, "Cannot open output file.\n");
        exit(1);
      }

      compile(file);
      return 0;
    }
  }

  fprintf(stderr, "Invalid arguments.\n");
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xdabf(%rip), %rbp      # 0x13200
movb $0x1, (%rbp)
xorl %r14d, %r14d
cmpl $0x2, %edi
setge %bl
jl 0x57bb
movq %rsi, %r15
movl %edi, 0x4(%rsp)
movl %edi, %r13d
movl $0x1, %r12d
movq (%r15,%r12,8), %r14
movq %r14, %rdi
leaq 0x79ed(%rip), %rsi      # 0xd15b
callq 0x10e0
testl %eax, %eax
je 0x57b1
movq %r14, %rdi
leaq 0x79e0(%rip), %rsi      # 0xd161
callq 0x10e0
testl %eax, %eax
je 0x57df
movq %r14, %rdi
leaq 0x79f3(%rip), %rsi      # 0xd187
callq 0x10e0
testl %eax, %eax
jne 0x57f8
movb $0x0, (%rbp)
incq %r12
cmpq %r13, %r12
setb %bl
jne 0x5760
xorl %r14d, %r14d
jmp 0x57bb
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x11e0
testb $0x1, %bl
je 0x57d2
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x17bc
movl $0x1, %r14d
jmp 0x57c0
leal 0x2(%r12), %eax
cmpl 0x4(%rsp), %eax
jle 0x5885
callq 0x17a0
jmp 0x589a
movq %r14, %rdi
callq 0x560c
movq %rax, 0xda09(%rip)      # 0x13210
movq %r14, %rdi
callq 0x1090
leaq 0x5(%rax), %rsi
movl $0x1, %edi
callq 0x10d0
movq %rax, %r12
movq %rax, 0xda19(%rip)      # 0x13240
movq %rax, %rdi
movq %r14, %rsi
callq 0x1060
movq %r12, %rdi
callq 0x1090
movq %rax, %r15
leaq (%r12,%rax), %rdi
addq $-0x2, %rdi
leaq 0x793e(%rip), %rsi      # 0xd18a
callq 0x10e0
testl %eax, %eax
jne 0x5895
addq %r12, %r15
movb $0x73, -0x1(%r15)
leaq 0x784a(%rip), %rsi      # 0xd0ae
movq %r12, %rdi
callq 0x1150
movq %rax, 0xd9ad(%rip)      # 0x13220
testq %rax, %rax
je 0x58a5
movq %r14, %rdi
callq 0x1384
jmp 0x57ac
movq %r15, %rdi
movq %r12, %rsi
callq 0x176c
jmp 0x57ac
callq 0x172b
movl $0x1, %r14d
jmp 0x57bb
callq 0x1747
nop
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_num
Node *new_node_num(long val, Token *token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_NUM;
  node->num_val = val;
  node->token = token;
  node->type = new_type_int();
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %r15
movl $0x1, (%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x50(%rax)
xorl %eax, %eax
callq 0xad70
movq %rax, 0x58(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_ident
Node *new_node_ident(Token *token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_IDENT;
  node->token = token;
  return node;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x0, (%rax)
movq %rbx, 0x50(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_lvar
Node *new_node_lvar(LVar *lvar, Token *token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_LVAR;
  node->lvar = lvar;
  node->token = token;
  node->type = lvar->type;
  return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x18, (%rax)
movq %r14, 0x30(%rax)
movq %rbx, 0x50(%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x58(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_gvar
Node *new_node_gvar(Global *gvar, Token *token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_GVAR;
  node->token = token;
  node->type = gvar->type;
  return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x19, (%rax)
movq %rbx, 0x50(%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x58(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_binary
Node *new_node_binary(NodeKind kind, Node *lhs, Node *rhs, Token *op_token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = kind;
  node->lhs = get_ptr_if_array(lhs);
  node->rhs = get_ptr_if_array(rhs);
  node->token = op_token;
  // node->type = type(node);
  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %r12
movl %ebp, (%rax)
movq %r15, %rdi
callq 0x5b59
movq %rax, 0x8(%r12)
movq %r14, %rdi
callq 0x5b59
movq %rax, 0x10(%r12)
movq %rbx, 0x50(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/parse.c
// Function: get_ptr_if_array
Node *get_ptr_if_array(Node *node) {
  if (!node) return NULL;
  if (is_array(type(node))) {
    return new_node_expr(ND_ADDR, node, NULL, node->token);
  } else {
    return node;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5ba4
movq %rdi, %rbx
callq 0xb354
movq %rax, %rdi
callq 0xaea7
testb %al, %al
je 0x5ba6
movq 0x50(%rbx), %r14
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x16, (%rax)
movq %rbx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %r14, 0x50(%rax)
movq %rax, %rbx
jmp 0x5ba6
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq