LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x4bb9
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, %al
leaq 0x83ef(%rip), %r15      # 0xcf2a
leaq 0x83de(%rip), %r12      # 0xcf20
leaq 0x8378(%rip), %r13      # 0xcec1
testb $0x1, %al
jne 0x4b62
movl $0x2, %esi
movl $0x1, %edx
movq %r13, %rdi
movq %r14, %rcx
callq 0x1190
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x475b
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x4b91
movl 0x28(%rax), %edx
movq 0x20(%rax), %rcx
movl 0x18(%rbx), %r8d
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x10f0
jmp 0x4ba6
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x1190
movq (%rbx), %rbx
xorl %eax, %eax
testq %rbx, %rbx
jne 0x4b49
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4c0b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, %al
leaq 0xe650(%rip), %r15      # 0x13220
leaq 0x82ea(%rip), %r14      # 0xcec1
testb $0x1, %al
jne 0x4bf0
movq (%r15), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x1190
movq (%r15), %rdi
movq 0x10(%rbx), %rsi
callq 0x475b
movq (%rbx), %rbx
xorl %eax, %eax
testq %rbx, %rbx
jne 0x4bd7
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe630(%rip), %rax      # 0x13248
movq (%rax), %r14
testq %r14, %r14
je 0x4c6b
leaq 0xe5f9(%rip), %r15      # 0x13220
leaq 0x82ff(%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 0x475b
movq (%r15), %rsi
movl $0xa, %edi
callq 0x10c0
movq (%r14), %r14
testq %r14, %r14
jne 0x4c2e
leaq 0xe5ae(%rip), %rax      # 0x13220
movq (%rax), %rsi
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O3/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 0xe5a0(%rip), %rax      # 0x13230
movq (%rax), %r14
leaq 0xe586(%rip), %r15      # 0x13220
movq (%r15), %rcx
leaq 0x82a1(%rip), %rdi      # 0xcf45
movl $0xb, %esi
movl $0x1, %edx
callq 0x1190
testq %r14, %r14
je 0x4d01
leaq 0x8292(%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 0x475b
movq 0x18(%r14), %rdi
callq 0x408c
movq (%r15), %rsi
movl $0xa, %edi
callq 0x10c0
movq (%r14), %r14
testq %r14, %r14
jne 0x4cbf
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe555(%rip), %rax      # 0x13268
movq (%rax), %r14
leaq 0xe503(%rip), %r15      # 0x13220
movq (%r15), %rcx
leaq 0x8233(%rip), %rdi      # 0xcf5a
movl $0xd, %esi
movl $0x1, %edx
callq 0x1190
testq %r14, %r14
je 0x4d7b
leaq 0x820f(%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 0x475b
movq (%r15), %rsi
movl $0xa, %edi
callq 0x10c0
movq (%r14), %r14
testq %r14, %r14
jne 0x4d42
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe48d(%rip), %r12      # 0x13220
movq (%r12), %rcx
leaq 0x81ca(%rip), %rdi      # 0xcf68
movl $0xb, %esi
movl $0x1, %edx
callq 0x1190
leaq 0xe464(%rip), %r13      # 0x13218
movq (%r13), %rdi
callq 0x3f3a
testl %eax, %eax
jle 0x4e47
leaq 0x836a(%rip), %r14      # 0xd136
leaq 0x7cc5(%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 0x817b(%rip), %rdi      # 0xcf74
callq 0x1190
testq %rbx, %rbx
je 0x4e1e
movq (%r12), %rdi
movl 0x28(%rbx), %edx
movq 0x20(%rbx), %rcx
movq %r15, %rsi
xorl %eax, %eax
callq 0x10f0
movq 0x8(%rbx), %rbx
jmp 0x4dfe
movq (%r12), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x1190
incq %rbp
movq (%r13), %rdi
callq 0x3f3a
cltq
cmpq %rax, %rbp
jl 0x4dd5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe3f0(%rip), %rax      # 0x13258
movq (%rax), %r13
leaq 0xe3ae(%rip), %r12      # 0x13220
movq (%r12), %rcx
leaq 0x80fc(%rip), %rdi      # 0xcf79
movl $0xd, %esi
movl $0x1, %edx
callq 0x1190
testq %r13, %r13
je 0x4fa0
leaq 0x80eb(%rip), %rbx      # 0xcf87
leaq 0x80f1(%rip), %r14      # 0xcf94
leaq 0x8109(%rip), %r15      # 0xcfb3
leaq 0x80a0(%rip), %rbp      # 0xcf51
movq 0x8(%r13), %rcx
movq (%r12), %rax
testq %rcx, %rcx
je 0x4ed4
movl 0x28(%rcx), %edx
movq 0x20(%rcx), %rcx
movq %rax, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10f0
jmp 0x4ee9
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x1190
movq 0x10(%r13), %rdi
callq 0xad89
testb %al, %al
je 0x4f1f
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 0x4b1a
jmp 0x4f53
movq 0x10(%r13), %rdi
callq 0xad90
testb %al, %al
je 0x4f78
movq (%r12), %rcx
movl $0x7, %esi
movl $0x1, %edx
leaq 0x805d(%rip), %rdi      # 0xcf9e
callq 0x1190
movq 0x10(%r13), %rax
movq 0x20(%rax), %rdi
callq 0x4bba
movq (%r12), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
callq 0x1190
movq (%r13), %r13
testq %r13, %r13
jne 0x4eb1
jmp 0x4fa0
movq 0x10(%r13), %rdi
callq 0xad97
testb %al, %al
je 0x4f69
movq (%r12), %rdi
movq 0x10(%r13), %rax
movl 0x28(%rax), %edx
leaq 0x800f(%rip), %rsi      # 0xcfa6
xorl %eax, %eax
callq 0x10f0
jmp 0x4f69
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe265(%rip), %r14      # 0x13220
movq (%r14), %rcx
leaq 0x7ff1(%rip), %rdi      # 0xcfb6
movl $0xc, %esi
movl $0x1, %edx
callq 0x1190
leaq 0xe285(%rip), %rax      # 0x13260
movq (%rax), %r15
testq %r15, %r15
je 0x5023
leaq 0x7f67(%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 0x475b
movq (%r14), %rsi
movl $0xa, %edi
callq 0x10c0
movq (%r15), %r15
testq %r15, %r15
jne 0x4fea
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x507e
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 0x5075
incq %rax
incl %ebp
movq %rax, %rdi
movl $0xa, %esi
callq 0x10a0
testq %rax, %rax
je 0x5075
cmpq %rbx, %rax
jbe 0x5059
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7f3e(%rip), %rdi      # 0xcfc3
xorl %eax, %eax
callq 0x508c
// File: /workspace/github_c_makefile_star2_O3/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 0x518b
movq %r15, %r14
incq %r14
incl %ebp
movq %r14, %rdi
movl $0xa, %esi
callq 0x10a0
movq %rax, %r15
testq %rax, %rax
sete %al
je 0x518b
cmpq %rbx, %r15
jbe 0x5166
testb %al, %al
je 0x519d
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_O3/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 0x5331
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 0x51ca
movq %rax, %r12
movq 0x20(%r15), %rdi
movq 0x10(%rax), %rsi
callq 0x5134
movl 0x28(%r15), %edx
movq %r12, %rdi
movq %rax, %rsi
callq 0x129b
movq 0xdc78(%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_O3/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 0x53f9
testq %rsi, %rsi
je 0x53f9
movq (%rsi), %rax
cmpq (%rdi), %rax
jae 0x53ea
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
cmpq %rax, 0x8(%rdi)
jae 0x53f8
movq %rax, 0x8(%rdi)
retq
pushq %rax
callq 0x130a
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x54ef
movl $0x2ffff0, %ecx         # imm = 0x2FFFF0
btl %eax, %ecx
jae 0x5466
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 0x5404
movq %rbx, %rdi
movq %rax, %rsi
callq 0x53d5
movq 0x10(%r14), %rdi
jmp 0x54d0
movl $0x300000f, %ecx        # imm = 0x300000F
btl %eax, %ecx
jae 0x549a
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 0x54e0
movl $0x1cc00000, %ecx       # imm = 0x1CC00000
btl %eax, %ecx
jae 0x54ef
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 0x5404
movq %rbx, %rdi
movq %rax, %rsi
callq 0x53d5
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 0x54e0
// File: /workspace/github_c_makefile_star2_O3/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 0x5563
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 0x5404
movq %rax, %r15
movq (%rax), %rdi
callq 0x51ca
movq %rax, %r12
movq (%r15), %rdi
movq 0x10(%rax), %rsi
callq 0x5134
movl 0x8(%r15), %edx
subl (%r15), %edx
movq %r12, %rdi
movq %rax, %rsi
callq 0x129b
movq 0xda3d(%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_O3/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 0x83fb(%rip), %rsi      # 0xd9ea
callq 0x1150
movq %rax, %rbx
testq %rax, %rax
jne 0x561c
callq 0x1030
movl (%rax), %edi
callq 0x11a0
leaq 0x7abb(%rip), %rdi      # 0xd0ca
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x508c
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1130
cmpl $-0x1, %eax
jne 0x5650
callq 0x1030
movl (%rax), %edi
callq 0x11a0
leaq 0x7a9b(%rip), %rdi      # 0xd0de
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x508c
movq %rbx, %rdi
callq 0x1100
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1130
cmpl $-0x1, %eax
jne 0x568c
callq 0x1030
movl (%rax), %edi
callq 0x11a0
leaq 0x7a5f(%rip), %rdi      # 0xd0de
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x508c
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 0x56bd
cmpb $0xa, -0x1(%r14,%r15)
je 0x56c5
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_O3/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 0xdaeb(%rip), %rax      # 0x13200
movb $0x1, (%rax)
movl %edi, 0x4(%rsp)
cmpl $0x2, %edi
jl 0x5785
movq %rsi, %r14
movl 0x4(%rsp), %ebp
movl $0x1, %r15d
leaq 0x7a26(%rip), %r12      # 0xd15b
leaq 0x7a25(%rip), %r13      # 0xd161
movq (%r14,%r15,8), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10e0
testl %eax, %eax
je 0x578f
movq %rbx, %rdi
movq %r13, %rsi
callq 0x10e0
testl %eax, %eax
je 0x583c
cmpb $0x2d, (%rbx)
jne 0x579d
cmpb $0x76, 0x1(%rbx)
jne 0x579d
cmpb $0x0, 0x2(%rbx)
jne 0x579d
leaq 0xda86(%rip), %rax      # 0x13200
movb $0x0, (%rax)
incq %r15
cmpq %r15, %rbp
jne 0x573c
callq 0x1769
jmp 0x5826
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x11e0
jmp 0x582b
movq %rbx, %rdi
callq 0x55e0
movq %rax, 0xda64(%rip)      # 0x13210
movq %rbx, %rdi
callq 0x1090
leaq 0x5(%rax), %rsi
movl $0x1, %edi
callq 0x10d0
movq %rax, %r14
movq %rax, 0xda74(%rip)      # 0x13240
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1060
movq %r14, %rdi
callq 0x1090
cmpb $0x2e, -0x2(%r14,%rax)
jne 0x5821
cmpb $0x63, -0x1(%r14,%rax)
jne 0x5821
cmpb $0x0, (%r14,%rax)
jne 0x5821
movb $0x73, -0x1(%r14,%rax)
leaq 0x78ab(%rip), %rsi      # 0xd0ae
movq %r14, %rdi
callq 0x1150
movq %rax, 0xda0e(%rip)      # 0x13220
testq %rax, %rax
je 0x585c
movq %rbx, %rdi
callq 0x1384
jmp 0x5858
callq 0x1728
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leal 0x2(%r15), %eax
cmpl 0x4(%rsp), %eax
jle 0x584d
callq 0x17b9
jmp 0x5826
movq %r14, %rdi
movq %r15, %rsi
callq 0x1785
xorl %ebx, %ebx
jmp 0x582b
callq 0x1744
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xac48
movq %rax, 0x58(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rbx, 0x50(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5b0b
movq %rax, 0x8(%r12)
movq %r14, %rdi
callq 0x5b0b
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_O3/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 0x5b4e
movq %rdi, %rbx
callq 0xb225
movq %rax, %rdi
callq 0xad7b
testb %al, %al
je 0x5b50
movq 0x50(%rbx), %r14
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x16, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, 0x50(%rax)
movq %rax, %rbx
jmp 0x5b50
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_member
Node *new_node_member(Node *lhs, Token *ident) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_MEMBER;
  node->lhs = lhs;
  node->token = ident;
  Type *ty = type(lhs);
  if (!is_struct(ty))
    error_at_node(lhs, "The expression must have a struct or union type.");
  MemberInfo *mem = get_member_type(ty, ident);
  if (!mem) error_at_token(ident, "The member does not exists in the struct.");
  node->offset = mem->offset;
  node->type = mem->type;
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %rbx
movl $0x1b, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x50(%rax)
movq %r15, %rdi
callq 0xb225
movq %rax, %r12
movq %rax, %rdi
callq 0xad89
testb %al, %al
jne 0x5c27
leaq 0x76d4(%rip), %rsi      # 0xd2f1
movq %r15, %rdi
xorl %eax, %eax
callq 0x5502
movq %r12, %rdi
movq %r14, %rsi
callq 0x5c69
movq %rax, %r15
testq %rax, %rax
jne 0x5c4b
leaq 0x76e1(%rip), %rsi      # 0xd322
movq %r14, %rdi
xorl %eax, %eax
callq 0x52cd
movl 0x18(%r15), %eax
movl %eax, 0x38(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: get_member_type
MemberInfo *get_member_type(Type *type, Token *ident) {
  if (!is_struct(type)) error_at_token(ident, "Not a struct.");
  MemberInfo *member;
  if (!type->tag_name) {
    if (!type->member)
      error_at_token(ident, "No tag name and the type has no member.");
    member = type->member;
  } else {
    TagName *tag = find_tag(type->tag_name);
    if (!tag) error_at_token(ident, "Undefined tag name.");
    member = tag->type->member;
  }

  while (member) {
    if (cmp_token(member->ident, ident)) return member;
    member = member->next;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xad89
testb %al, %al
jne 0x5c8e
leaq 0x7733(%rip), %rsi      # 0xd3b7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x52cd
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x5cc7
callq 0x647f
movq %rax, %r14
testq %rax, %rax
jne 0x5cb5
leaq 0x7742(%rip), %rsi      # 0xd3ed
movq %rbx, %rdi
xorl %eax, %eax
callq 0x52cd
movq 0x10(%r14), %r14
addq $0x20, %r14
movq (%r14), %r15
testq %r15, %r15
jne 0x5cd0
jmp 0x5cfa
movq 0x20(%r14), %r15
testq %r15, %r15
je 0x5d06
movslq 0x28(%rbx), %r14
movq 0x8(%r15), %rax
cmpl %r14d, 0x28(%rax)
jne 0x5cf2
movq 0x20(%rax), %rdi
movq 0x20(%rbx), %rsi
movq %r14, %rdx
callq 0x1120
testl %eax, %eax
je 0x5cfd
movq (%r15), %r15
testq %r15, %r15
jne 0x5cd4
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
addq $0x20, %r14
leaq 0x76b4(%rip), %rsi      # 0xd3c5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x52cd
jmp 0x5cbd
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_if_then
Node *new_node_if_then(Node *cond_, Node *then_, Node *else_) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_IF;
  node->lhs = cond_;
  node->rhs = then_;
  node->xhs = else_;
  node->token = token;
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x1d, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
leaq 0xd43f(%rip), %rcx      # 0x13228
movq (%rcx), %rcx
movq %rcx, 0x50(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_switch
Node *new_node_switch(Node *expr, Node *stmt, Token *token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_SWITCH;
  node->lvar = new_lvar(token, new_type_int());
  node->lhs = expr;
  node->rhs = stmt;
  node->nodes = vec_new();
  node->token = token;
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %r12
movl $0x20, (%rax)
xorl %eax, %eax
callq 0xac48
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5e60
movq %rax, 0x30(%r12)
movq %r15, 0x8(%r12)
movq %r14, 0x10(%r12)
xorl %eax, %eax
callq 0x3f0c
movq %rax, 0x48(%r12)
movq %rbx, 0x50(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: new_lvar
LVar *new_lvar(Token *token, Type *type) {
  LVar *lvar = calloc(1, sizeof(LVar));
  lvar->token = token;
  int offset;
  int size = sizeof_type(type);
  if (size == 0) {
    print_structs();
    error_at_token(token, "Inncomplete type is not allowed.");
  }
  if (locals) {
    offset = locals->offset + size;
  } else {
    offset = size;
    if (cur_fn->type->variadic) {
      offset += 128;
    } else {
      offset += 32;
    };
  }
  lvar->offset = offset;
  lvar->type = type;
  lvar->next = locals;
  locals = lvar;
  lvar->scope = scope;
  scope = lvar;

  return lvar;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x10d0
movq %rax, %rbx
movq %r15, 0x8(%rax)
movq %r14, %rdi
callq 0xae77
movl %eax, %ebp
testl %eax, %eax
jne 0x5ea9
xorl %eax, %eax
callq 0x4e56
leaq 0x74f7(%rip), %rsi      # 0xd396
movq %r15, %rdi
xorl %eax, %eax
callq 0x52cd
leaq 0xd398(%rip), %rax      # 0x13248
movq (%rax), %rcx
testq %rcx, %rcx
je 0x5ebd
addl 0x18(%rcx), %ebp
jmp 0x5ed6
movq 0xd3ac(%rip), %rdx      # 0x13270
movq 0x10(%rdx), %rdx
cmpb $0x1, 0x38(%rdx)
jne 0x5ed3
subl $-0x80, %ebp
jmp 0x5ed6
addl $0x20, %ebp
movl %ebp, 0x18(%rbx)
movq %r14, 0x10(%rbx)
movq %rcx, (%rbx)
movq %rbx, (%rax)
leaq 0xd366(%rip), %rax      # 0x13250
movq (%rax), %rcx
movq %rcx, 0x20(%rbx)
movq %rbx, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_while
Node *new_node_while(Node *cond_, Node *do_) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_WHILE;
  node->lhs = cond_;
  node->rhs = do_;
  node->token = token;
  return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x1e, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
leaq 0xd294(%rip), %rcx      # 0x13228
movq (%rcx), %rcx
movq %rcx, 0x50(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_for
Node *new_node_for(Node *init_, Node *cond_, Node *post_, Node *body_,
                   Token *token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_FOR;
  node->lhs = init_;
  node->rhs = cond_;
  node->xhs = post_;
  Vector *vec = vec_new();
  vec_push(vec, body_);
  node->nodes = vec;
  node->token = token;
  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %rbp
movl $0x1f, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
xorl %eax, %eax
callq 0x3f0c
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x3f3e
movq %r15, 0x48(%rbp)
movq %rbx, 0x50(%rbp)
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_block
Node *new_node_block(Vector *stmts) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_BLOCK;
  node->nodes = stmts;
  node->token = token;
  return node;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x26, (%rax)
movq %rbx, 0x48(%rax)
leaq 0xd1f4(%rip), %rcx      # 0x13228
movq (%rcx), %rcx
movq %rcx, 0x50(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: consume_number
long consume_number() {
  if (token->kind != TK_NUM) {
    error_at_token(token, "Unexpected token: Number is expected.");
  }
  int num = token->num_val;
  token = token->next;
  return num;
}

// Assembly:
pushq %rbx
leaq 0xd119(%rip), %rbx      # 0x13228
movq (%rbx), %rdi
cmpl $0x1, (%rdi)
je 0x6128
leaq 0x723d(%rip), %rsi      # 0xd35b
xorl %eax, %eax
callq 0x52cd
movq (%rbx), %rdi
movslq 0x10(%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: consume_ident
Token *consume_ident() {
  if (token->kind != TK_IDENT) {
    error_at_token(token, "Expected identifier.");
  }
  Token *ident = token;
  token = token->next;
  return ident;
}

// Assembly:
pushq %rbx
leaq 0xd0eb(%rip), %rbx      # 0x13228
movq (%rbx), %rax
cmpl $0x0, (%rax)
je 0x6159
leaq 0x7235(%rip), %rsi      # 0xd381
movq %rax, %rdi
xorl %eax, %eax
callq 0x52cd
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: expect
Token *expect(TokenKind kind) {
  if (token->kind != kind) {
    error_at_token(token, "Unexpected token.");
  }
  Token *ret = token;
  token = token->next;
  return ret;
}

// Assembly:
pushq %rbx
leaq 0xd0be(%rip), %rbx      # 0x13228
movq (%rbx), %rax
cmpl %edi, (%rax)
je 0x6185
leaq 0x72ee(%rip), %rsi      # 0xd466
movq %rax, %rdi
xorl %eax, %eax
callq 0x52cd
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: find_typedef
Type *find_typedef(Token *ident) {
  if (!ident) return NULL;
  Typedef *tdef = tdef_names;
  while (tdef) {
    if (cmp_token(tdef->ident, ident)) {
      return tdef->type;
    }
    tdef = tdef->next;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6266
leaq 0xd035(%rip), %rax      # 0x13260
movq (%rax), %r12
testq %r12, %r12
je 0x6266
movq %rdi, %r14
movslq 0x28(%rdi), %r15
xorl %ebx, %ebx
movq 0x10(%r12), %rax
cmpl %r15d, 0x28(%rax)
jne 0x625b
movq 0x20(%rax), %rdi
movq 0x20(%r14), %rsi
movq %r15, %rdx
callq 0x1120
testl %eax, %eax
je 0x6277
movq (%r12), %r12
testq %r12, %r12
jne 0x623c
jmp 0x6268
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r12), %rbx
jmp 0x6268
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: find_lvar
LVar *find_lvar(Token *token) {
  for (LVar *var = scope; var; var = var->scope) {
    if (cmp_token(var->token, token)) {
      return var;
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xcfc6(%rip), %rax      # 0x13250
movq (%rax), %rbx
testq %rbx, %rbx
je 0x62c0
movq %rdi, %r14
movslq 0x28(%rdi), %r15
movq 0x8(%rbx), %rax
cmpl %r15d, 0x28(%rax)
jne 0x62b7
movq 0x20(%rax), %rdi
movq 0x20(%r14), %rsi
movq %r15, %rdx
callq 0x1120
testl %eax, %eax
je 0x62c2
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0x6299
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: find_lvar_in_scope
bool find_lvar_in_scope(Token *token) {
  for (LVar *var = scope; var; var = var->scope) {
    if (var->scope_head) return false;
    if (cmp_token(var->token, token)) {
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xcf7a(%rip), %rax      # 0x13250
movq (%rax), %r14
testq %r14, %r14
je 0x6313
movq %rdi, %rbx
cmpb $0x0, 0x28(%r14)
jne 0x6317
movq 0x8(%r14), %rax
movslq 0x28(%rax), %rdx
cmpl 0x28(%rbx), %edx
jne 0x6306
movq 0x20(%rax), %rdi
movq 0x20(%rbx), %rsi
callq 0x1120
testl %eax, %eax
je 0x631d
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x62e1
xorl %eax, %eax
jmp 0x6321
xorl %eax, %eax
jmp 0x6323
movb $0x1, %al
xorl %ecx, %ecx
jmp 0x6321
movb $0x1, %al
movb $0x1, %cl
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: new_gvar
Global *new_gvar(Token *ident, Type *type) {
  Global *global = calloc(1, sizeof(Global));
  global->next = globals;
  global->token = ident;
  global->type = type;
  globals = global;
  return global;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x28, %esi
callq 0x10d0
leaq 0xcee5(%rip), %rcx      # 0x13230
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: find_gvar
Global *find_gvar(Token *token) {
  for (Global *var = globals; var; var = var->next) {
    if (cmp_token(var->token, token)) {
      return var;
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xcec0(%rip), %rax      # 0x13230
movq (%rax), %rbx
testq %rbx, %rbx
je 0x63a5
movq %rdi, %r14
movslq 0x28(%rdi), %r15
movq 0x8(%rbx), %rax
cmpl %r15d, 0x28(%rax)
jne 0x639d
movq 0x20(%rax), %rdi
movq 0x20(%r14), %rsi
movq %r15, %rdx
callq 0x1120
testl %eax, %eax
je 0x63a7
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x637f
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: new_func
Function *new_func(Token *ident, Type *type, Node *body) {
  Function *func = calloc(1, sizeof(Function));
  func->next = functions;
  func->token = ident;
  func->type = type;
  func->body = body;
  functions = func;
  return func;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x28, %esi
callq 0x10d0
leaq 0xce94(%rip), %rcx      # 0x13268
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: find_func
Function *find_func(Token *token) {
  for (Function *func = functions; func; func = func->next) {
    if (cmp_token(func->token, token)) {
      return func;
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xce6d(%rip), %rax      # 0x13268
movq (%rax), %rbx
testq %rbx, %rbx
je 0x6430
movq %rdi, %r14
movslq 0x28(%rdi), %r15
movq 0x8(%rbx), %rax
cmpl %r15d, 0x28(%rax)
jne 0x6428
movq 0x20(%rax), %rdi
movq 0x20(%r14), %rsi
movq %r15, %rdx
callq 0x1120
testl %eax, %eax
je 0x6432
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x640a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: new_tag
TagName *new_tag(Token *ident, Type *type) {
  if (!ident) return NULL;
  TagName *tag = calloc(1, sizeof(TagName));
  type->tag_name = ident;
  tag->next = tagnames;
  tag->ident = ident;
  tag->type = type;
  tagnames = tag;
}

// Assembly:
testq %rdi, %rdi
je 0x647c
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0x10d0
movq %r14, 0x30(%rbx)
leaq 0xcdf4(%rip), %rcx      # 0x13258
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: find_tag
TagName *find_tag(Token *token) {
  if (!token) return NULL;
  for (TagName *tag = tagnames; tag; tag = tag->next) {
    if (cmp_token(tag->ident, token)) {
      return tag;
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x64c5
leaq 0xcdc8(%rip), %rax      # 0x13258
movq (%rax), %rbx
testq %rbx, %rbx
je 0x64c5
movq %rdi, %r14
movslq 0x28(%rdi), %r15
movq 0x8(%rbx), %rax
cmpl %r15d, 0x28(%rax)
jne 0x64bd
movq 0x20(%rax), %rdi
movq 0x20(%r14), %rsi
movq %r15, %rdx
callq 0x1120
testl %eax, %eax
je 0x64c7
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x649f
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: new_typedef
Typedef *new_typedef(Token *ident, Type *type) {
  if (!ident) return NULL;
  Typedef *tdef = calloc(1, sizeof(Typedef));
  tdef->next = tdef_names;
  tdef->ident = ident;
  tdef->type = type;
  tdef_names = tdef;
}

// Assembly:
testq %rdi, %rdi
je 0x650d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0x10d0
leaq 0xcd6b(%rip), %rcx      # 0x13260
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x8(%rax)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: pointer_add
Node *pointer_add(Node *ptr, Node *offset, Token *token) {
  offset = new_node_binary(ND_MUL, offset,
                           new_node_num(sizeof_type(type(ptr)->ptr_to), token),
                           token);
  return new_node_binary(ND_ADD, ptr, offset, token);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xb225
movq 0x8(%rax), %rdi
callq 0xae77
movslq %eax, %r13
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %r12
movl $0x1, (%rax)
movq %r13, 0x20(%rax)
movq %rbx, 0x50(%rax)
xorl %eax, %eax
callq 0xac48
movq %rax, 0x58(%r12)
movl $0x6, %edi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x5ab9
movl $0x4, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5ab9
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_decl
MemberInfo *parse_decl(bool allow_undefined_tag) {
  // declaration-specifiers
  if (!is_type_specifier(token))
    error_at_token(token, "Expected type specifier or typedef name.");

  Type *type = parse_type_specifier(allow_undefined_tag);
  return parse_declaretor(type);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xc186(%rip), %rax      # 0x13228
movq (%rax), %r14
movl (%r14), %eax
leal -0x34(%rax), %ecx
cmpl $0x8, %ecx
jb 0x70d6
addl $-0x3d, %eax
cmpl $0x2, %eax
jb 0x70d6
movq %r14, %rdi
callq 0x6217
testq %rax, %rax
jne 0x70d6
leaq 0x666f(%rip), %rsi      # 0xd73b
movq %r14, %rdi
xorl %eax, %eax
callq 0x52cd
movzbl %bl, %edi
callq 0x8750
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8156
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_cast_expr
Node *parse_cast_expr() {
  if (peek(TK_OP_PAREN) && is_type_specifier(token->next)) {
    expect(TK_OP_PAREN);
    Token *op_token = token;
    MemberInfo *info = parse_decl(false);
    expect(TK_CL_PAREN);
    Node *node = new_node_cast(parse_cast_expr(), info->type, op_token);
    return node;
  }
  return parse_unary_expr();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xc12f(%rip), %r15      # 0x13228
movq (%r15), %rax
cmpl $0x1d, (%rax)
jne 0x7188
movq 0x8(%rax), %rbx
movl (%rbx), %eax
leal -0x34(%rax), %ecx
cmpl $0x8, %ecx
jb 0x7128
addl $-0x3d, %eax
cmpl $0x2, %eax
jb 0x7128
movq %rbx, %rdi
callq 0x6217
testq %rax, %rax
je 0x7188
movq %rbx, (%r15)
xorl %edi, %edi
callq 0x7095
movq %rax, %r14
movq (%r15), %rdi
cmpl $0x1e, (%rdi)
je 0x714e
leaq 0x6322(%rip), %rsi      # 0xd466
xorl %eax, %eax
callq 0x52cd
movq (%r15), %rdi
movq 0x8(%rdi), %rax
movq %rax, (%r15)
callq 0x70ed
movq %rax, %r15
movq 0x10(%r14), %r14
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x1c, (%rax)
movq %rbx, 0x50(%rax)
movq %r14, 0x58(%rax)
movq %r15, 0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
popq %rbx
popq %r14
popq %r15
jmp 0x6e4e
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_mul_expr
Node *parse_mul_expr() {
  Node *lhs = parse_cast_expr();
  Node *rhs;

  while (true) {
    Token *op_token = token;
    if (consume_if(TK_MUL)) {
      rhs = parse_cast_expr();
      lhs = new_node_binary_arith(ND_MUL, lhs, rhs, op_token);
      continue;
    } else if (consume_if(TK_DIV)) {
      rhs = parse_cast_expr();
      lhs = new_node_binary_arith(ND_DIV, lhs, rhs, op_token);
      continue;
    }
    return lhs;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x70ed
movq %rax, %rbx
leaq 0xc07f(%rip), %r12      # 0x13228
movq (%r12), %r14
movl (%r14), %eax
movl $0x6, %ebp
cmpl $0x5, %eax
je 0x71c4
cmpl $0x6, %eax
jne 0x71f9
movl $0x7, %ebp
movq 0x8(%r14), %rax
movq %rax, (%r12)
callq 0x70ed
movq %rax, %r15
movq %rbx, %rdi
callq 0xb1f9
movq %r15, %rdi
callq 0xb1f9
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5ab9
movq %rax, %rbx
jmp 0x71a9
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_add_expr
Node *parse_add_expr() {
  Node *lhs = parse_mul_expr();
  Node *rhs;
  while (true) {
    Token *op_token = token;

    if (consume_if(TK_ADD)) {
      rhs = parse_mul_expr();
      if (is_ptr(type(lhs)) && is_arith(type(rhs))) {
        lhs = pointer_add(lhs, rhs, op_token);
      } else if (is_arith(type(lhs)) && is_ptr(type(rhs))) {
        lhs = pointer_add(rhs, lhs, op_token);
      } else {
        lhs = new_node_binary(ND_ADD, lhs, rhs, op_token);
      }
      continue;
    } else if (consume_if(TK_SUB)) {
      rhs = parse_mul_expr();
      if (is_ptr(type(lhs)) && is_arith(type(rhs))) {
        lhs = pointer_sub(lhs, rhs, op_token);
      } else if (is_ptr(type(lhs)) && is_arith(type(rhs))) {
        lhs = pointer_sub(rhs, lhs, op_token);
      } else {
        lhs = new_node_binary(ND_SUB, lhs, rhs, op_token);
      }
      continue;
    }
    return lhs;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x7192
movq %rax, %rbx
leaq 0xc00c(%rip), %r12      # 0x13228
movq (%r12), %r14
movl (%r14), %eax
cmpl $0x4, %eax
je 0x727c
cmpl $0x3, %eax
jne 0x735a
movq 0x8(%r14), %rax
movq %rax, (%r12)
callq 0x7192
movq %rax, %r15
movq %rbx, %rdi
callq 0xb225
movq %rax, %rdi
callq 0xad74
testb %al, %al
je 0x72fa
movq %r15, %rdi
callq 0xb225
movq %rax, %rdi
callq 0xadc4
testb %al, %al
je 0x72fa
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x7328
movq 0x8(%r14), %rax
movq %rax, (%r12)
callq 0x7192
movq %rax, %r15
movq %rbx, %rdi
callq 0xb225
movq %rax, %rdi
callq 0xad74
testb %al, %al
je 0x72bc
movq %r15, %rdi
callq 0xb225
movq %rax, %rdi
callq 0xadc4
testb %al, %al
je 0x72bc
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x72ea
movq %rbx, %rdi
callq 0xb225
movq %rax, %rdi
callq 0xad74
testb %al, %al
je 0x7338
movq %r15, %rdi
callq 0xb225
movq %rax, %rdi
callq 0xadc4
testb %al, %al
je 0x7338
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6879
movq %rax, %rbx
jmp 0x721c
movq %rbx, %rdi
callq 0xb225
movq %rax, %rdi
callq 0xadc4
testb %al, %al
je 0x733f
movq %r15, %rdi
callq 0xb225
movq %rax, %rdi
callq 0xad74
testb %al, %al
je 0x733f
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x67fb
movq %rax, %rbx
jmp 0x721c
movl $0x5, %edi
jmp 0x7344
movl $0x4, %edi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5ab9
movq %rax, %rbx
jmp 0x721c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq