LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x406e
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
shll %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rsi
shlq $0x3, %rsi
callq 0x1140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x8(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x8(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/container.c
// Function: test_vec
void test_vec() {
  Vector *vec = vec_new();
  for (int i = 0; i < 100; i++) vec_push(vec, new_node_num(i, NULL));
  assert_expect(__LINE__, 100, vec_len(vec));
  assert_expect(__LINE__, 0, vec->data[0]->num_val);
  assert_expect(__LINE__, 50, vec->data[50]->num_val);
  assert_expect(__LINE__, 99, vec->data[99]->num_val);
  fprintf(stderr, "test_vec() cleared\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x3fb0
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jge 0x40ea
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x69f0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x4020
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x40b8
movq -0x8(%rbp), %rdi
callq 0x4000
movslq %eax, %rdx
movl $0x1c, %edi
movl $0x64, %esi
callq 0xb140
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdx
movl $0x1d, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xb140
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x190(%rax), %rax
movq 0x20(%rax), %rdx
movl $0x1e, %edi
movl $0x32, %esi
callq 0xb140
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x318(%rax), %rax
movq 0x20(%rax), %rdx
movl $0x1f, %edi
movl $0x63, %esi
callq 0xb140
movq 0x10e8e(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xb936(%rip), %rsi      # 0xfaaa
movb $0x0, %al
callq 0x10f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xba10(%rip), %rsi      # 0xfcab
movb $0x0, %al
callq 0x10f0
cmpq $0x0, -0x10(%rbp)
je 0x42df
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4190
movq -0x10(%rbp), %rax
cmpl $0x1c, (%rax)
jne 0x42d1
movq -0x8(%rbp), %rdi
leaq 0xb9e0(%rip), %rsi      # 0xfcaa
movb $0x0, %al
callq 0x10f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x42a2
movq -0x8(%rbp), %rdi
leaq 0xbde7(%rip), %rsi      # 0x100d1
movb $0x0, %al
callq 0x10f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10049(%rip), %rax     # 0x15228
movq (%rax), %rdi
callq 0x4000
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x5256
leaq 0x10028(%rip), %rax     # 0x15228
movq (%rax), %rax
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
leaq 0xfff7(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xaa88(%rip), %rsi      # 0xfcab
movb $0x0, %al
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0x4300
leaq 0xffd6(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xae8d(%rip), %rsi      # 0x100d1
movb $0x0, %al
callq 0x10f0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x51f1
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x530c
testb $0x1, -0x11(%rbp)
jne 0x5297
movq -0x8(%rbp), %rdi
leaq 0xabcb(%rip), %rsi      # 0xfe5b
movb $0x0, %al
callq 0x10f0
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4e10
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x52ea
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x28(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %r8d
leaq 0xabd9(%rip), %rsi      # 0xfeba
movb $0x0, %al
callq 0x10f0
jmp 0x52fc
movq -0x8(%rbp), %rdi
leaq 0xabcf(%rip), %rsi      # 0xfec4
movb $0x0, %al
callq 0x10f0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5274
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, -0x9(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x537d
testb $0x1, -0x9(%rbp)
jne 0x5355
leaq 0xfecc(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xab0d(%rip), %rsi      # 0xfe5b
movb $0x0, %al
callq 0x10f0
movb $0x0, -0x9(%rbp)
leaq 0xfeb0(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4e10
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5330
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xfe99(%rip), %rax      # 0x15238
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5420
leaq 0xfe5c(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x28(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %r8d
leaq 0xaaea(%rip), %rsi      # 0xfec7
movb $0x0, %al
callq 0x10f0
leaq 0xfe25(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4e10
leaq 0xfe0e(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xacc5(%rip), %rsi      # 0x100d1
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x53a6
leaq 0xfde9(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xaca0(%rip), %rsi      # 0x100d1
movb $0x0, %al
callq 0x10f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xfdd1(%rip), %rax      # 0x15220
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0xfdb3(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xaa78(%rip), %rsi      # 0xfedf
movb $0x0, %al
callq 0x10f0
cmpq $0x0, -0x8(%rbp)
je 0x54ed
leaq 0xfd94(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x28(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rcx
leaq 0xaa4e(%rip), %rsi      # 0xfeeb
movb $0x0, %al
callq 0x10f0
leaq 0xfd65(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4e10
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4300
leaq 0xfd41(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xabf8(%rip), %rsi      # 0x100d1
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x546e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xfd49(%rip), %rax      # 0x15258
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0xfcf3(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xa9cd(%rip), %rsi      # 0xfef4
movb $0x0, %al
callq 0x10f0
cmpq $0x0, -0x8(%rbp)
je 0x55a0
leaq 0xfcd4(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x28(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rcx
leaq 0xa98e(%rip), %rsi      # 0xfeeb
movb $0x0, %al
callq 0x10f0
leaq 0xfca5(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4e10
leaq 0xfc8e(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xab45(%rip), %rsi      # 0x100d1
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x552e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xfc51(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xa939(%rip), %rsi      # 0xff02
movb $0x0, %al
callq 0x10f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq 0xfc24(%rip), %rax      # 0x15208
movq (%rax), %rdi
callq 0x4000
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jge 0x5690
leaq 0xfc08(%rip), %rax      # 0x15208
movq (%rax), %rax
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0xfbf3(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xa8e7(%rip), %rsi      # 0xff0e
movb $0x0, %al
callq 0x10f0
cmpq $0x0, -0x10(%rbp)
je 0x566a
leaq 0xfbd4(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0xa433(%rip), %rsi      # 0xfa88
movb $0x0, %al
callq 0x10f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x562e
leaq 0xfb9f(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xaa55(%rip), %rsi      # 0x100d0
movb $0x0, %al
callq 0x10f0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x55d7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xfb99(%rip), %rax      # 0x15248
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0xfb53(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xa84c(%rip), %rsi      # 0xff13
movb $0x0, %al
callq 0x10f0
cmpq $0x0, -0x8(%rbp)
je 0x5830
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5715
leaq 0xfb25(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x28(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rcx
leaq 0xa7df(%rip), %rsi      # 0xfeeb
movb $0x0, %al
callq 0x10f0
jmp 0x572d
leaq 0xfaf4(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xa7fb(%rip), %rsi      # 0xff21
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xd3b0
testb $0x1, %al
jne 0x5740
jmp 0x5790
leaq 0xfac9(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xa7dd(%rip), %rsi      # 0xff2e
movb $0x0, %al
callq 0x10f0
leaq 0xfab1(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rsi
callq 0x5260
leaq 0xfa96(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xa7c9(%rip), %rsi      # 0xff4d
movb $0x0, %al
callq 0x10f0
jmp 0x5820
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xd3d0
testb $0x1, %al
jne 0x57a3
jmp 0x57e6
leaq 0xfa66(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xa784(%rip), %rsi      # 0xff38
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x5320
leaq 0xfa3d(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xa770(%rip), %rsi      # 0xff4d
movb $0x0, %al
callq 0x10f0
jmp 0x581e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xd3f0
testb $0x1, %al
jne 0x57f9
jmp 0x581c
leaq 0xfa10(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x28(%rax), %edx
leaq 0xa72b(%rip), %rsi      # 0xff40
movb $0x0, %al
callq 0x10f0
jmp 0x581e
jmp 0x5820
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x56ce
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xf9c1(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xa6f7(%rip), %rsi      # 0xff50
movb $0x0, %al
callq 0x10f0
leaq 0xf9e9(%rip), %rax      # 0x15250
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x58e0
leaq 0xf994(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x28(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rcx
leaq 0xa64e(%rip), %rsi      # 0xfeeb
movb $0x0, %al
callq 0x10f0
leaq 0xf965(%rip), %rax      # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4e10
leaq 0xf94e(%rip), %rax      # 0x15210
movq (%rax), %rdi
leaq 0xa805(%rip), %rsi      # 0x100d1
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x586e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x591f
leaq 0xa645(%rip), %rdi      # 0xff5d
movb $0x0, %al
callq 0x5970
jmp 0x5921
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x595c
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jbe 0x5945
jmp 0x595c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5921
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5a82
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jbe 0x5a6b
jmp 0x5a82
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5a47
cmpq $0x0, -0x18(%rbp)
jne 0x5a98
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x10a0
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x10d0
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/error.c
// Function: print_error_line
void print_error_line(FileInfo *fi, PosInfo *pos, int len) {
  fprintf(stderr, "error in file: %s:%d\n", fi->file_name, pos->line);
  fprintf(stderr, "%.*s\n", pos->line_len, pos->line_start);
  fprintf(stderr, "%*s%.*s\n", pos->pos_in_line, "", len,
          "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0xf43e(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
leaq 0xa3cd(%rip), %rsi      # 0xff9f
movb $0x0, %al
callq 0x10f0
movq 0xf418(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x9eab(%rip), %rsi      # 0xfaa4
movb $0x0, %al
callq 0x10f0
movq 0xf3f1(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
movl -0x14(%rbp), %r8d
leaq 0xa399(%rip), %rsi      # 0xffb5
leaq 0xa4af(%rip), %rcx      # 0x100d2
leaq 0xa394(%rip), %r9       # 0xffbe
movb $0x0, %al
callq 0x10f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x5c7b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5a30
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x5ba0
movq 0xf30a(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1160
movq 0xf2f3(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0xa3c2(%rip), %rsi      # 0x100d1
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x5d5b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5b00
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5a30
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
callq 0x5ba0
movq 0xf210(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1160
movq 0xf1f9(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0xa2c8(%rip), %rsi      # 0x100d1
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x1180
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5e9e
cmpq $0x0, -0x10(%rbp)
jne 0x5eb8
movq 0xf153(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0xa12d(%rip), %rsi      # 0xffdc
movb $0x0, %al
callq 0x10f0
jmp 0x5efa
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x5ed6
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x5ef8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x5efa
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x4, %eax
jb 0x5f61
jmp 0x5f1c
movl -0x14(%rbp), %eax
addl $-0x4, %eax
subl $0x10, %eax
jb 0x5f77
jmp 0x5f29
movl -0x14(%rbp), %eax
subl $0x15, %eax
je 0x5f77
jmp 0x5f33
movl -0x14(%rbp), %eax
addl $-0x16, %eax
subl $0x2, %eax
jb 0x5fcc
jmp 0x5f44
movl -0x14(%rbp), %eax
addl $-0x18, %eax
subl $0x2, %eax
jb 0x5f61
jmp 0x5f51
movl -0x14(%rbp), %eax
addl $-0x1a, %eax
subl $0x3, %eax
jb 0x5fcc
jmp 0x6000
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x5e20
movq %rax, -0x10(%rbp)
jmp 0x6029
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x5e20
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5f00
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5e80
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5f00
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x5e80
jmp 0x6029
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x5e20
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5f00
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x5e80
jmp 0x6029
movq 0xeff1(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0x9fd6(%rip), %rsi      # 0xffe7
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x5e20
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x607e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
callq 0x5f00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x5b00
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5a30
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %edx
callq 0x5ba0
movq 0xeed5(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1160
movq 0xeebe(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0x9f8d(%rip), %rsi      # 0x100d1
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x1180
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xaaed(%rip), %rsi      # 0x10c64
callq 0x1150
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x61b0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x1190
movq -0x28(%rbp), %rsi
movq %rax, %rdx
leaq 0x9ebb(%rip), %rdi      # 0x10064
movb $0x0, %al
callq 0x5970
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1130
cmpl $-0x1, %eax
jne 0x61f0
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x1190
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq 0x9e8f(%rip), %rdi      # 0x10078
movb $0x0, %al
callq 0x5970
movq -0x10(%rbp), %rdi
callq 0x1100
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1130
cmpl $-0x1, %eax
jne 0x623a
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x1190
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0x9e45(%rip), %rdi      # 0x10078
movb $0x0, %al
callq 0x5970
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movl $0x1, %edi
callq 0x10d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0x1070
cmpq $0x0, -0x18(%rbp)
je 0x6282
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x6299
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb $0xa, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x1080
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x10d0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movb $0x0, %al
callq 0xd0b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x18, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x19, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6eb0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x6eb0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6ecd
movq $0x0, -0x8(%rbp)
jmp 0x6f0c
movq -0x10(%rbp), %rdi
callq 0xdda0
movq %rax, %rdi
callq 0xd370
testb $0x1, %al
jne 0x6ee4
jmp 0x6f04
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
movl $0x16, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x6f70
movq %rax, -0x8(%rbp)
jmp 0x6f0c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1b, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rdi
callq 0xdda0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd3b0
testb $0x1, %al
jne 0x7051
movq -0x8(%rbp), %rdi
leaq 0x930b(%rip), %rsi      # 0x10355
movb $0x0, %al
callq 0x6040
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x70b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x707b
movq -0x10(%rbp), %rdi
leaq 0x9312(%rip), %rsi      # 0x10386
movb $0x0, %al
callq 0x5d20
movq -0x28(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd3b0
testb $0x1, %al
jne 0x70df
movq -0x18(%rbp), %rdi
leaq 0x9343(%rip), %rsi      # 0x1041b
movb $0x0, %al
callq 0x5d20
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x7115
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x7107
movq -0x18(%rbp), %rdi
leaq 0x9329(%rip), %rsi      # 0x10429
movb $0x0, %al
callq 0x5d20
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x714f
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x7ee0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x713f
movq -0x18(%rbp), %rdi
leaq 0x9319(%rip), %rsi      # 0x10451
movb $0x0, %al
callq 0x5d20
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7151
cmpq $0x0, -0x20(%rbp)
je 0x7186
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x79f0
testb $0x1, %al
jne 0x716f
jmp 0x7179
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x718e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7151
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: new_node
Node *new_node(NodeKind kind, Token *op_token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = kind;
  node->token = op_token;
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_cast
Node *new_node_cast(Node *lhs, Type *type, Token *op_token) {
  Node *node = new_node(ND_CAST, op_token);
  node->type = type;
  node->lhs = lhs;
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movl $0x1c, %edi
callq 0x71a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_call
Node *new_node_call(Node *callee, Vector *vec, Token *token) {
  // TODO: Currently, only ND_IDENT is allowed as a callee.
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_CALL;
  node->lhs = callee;
  node->nodes = vec;
  node->token = token;
  node->type = callee->type;
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1a, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1d, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq 0xdf0c(%rip), %rax      # 0x15218
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x20, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, %al
callq 0xd0b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x73d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movb $0x0, %al
callq 0x3fb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0xd640
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x742a
movb $0x0, %al
callq 0x56a0
movq -0x8(%rbp), %rdi
leaq 0x8fd7(%rip), %rsi      # 0x103fa
movb $0x0, %al
callq 0x5d20
leaq 0xde07(%rip), %rax      # 0x15238
cmpq $0x0, (%rax)
je 0x744c
leaq 0xddfa(%rip), %rax      # 0x15238
movq (%rax), %rax
movl 0x18(%rax), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x747b
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq 0xde07(%rip), %rax      # 0x15260
movq 0x10(%rax), %rax
testb $0x1, 0x38(%rax)
je 0x7470
movl -0x1c(%rbp), %eax
addl $0x80, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7479
movl -0x1c(%rbp), %eax
addl $0x20, %eax
movl %eax, -0x1c(%rbp)
jmp 0x747b
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0xdda0(%rip), %rax      # 0x15238
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
leaq 0xdd8b(%rip), %rax      # 0x15238
movq %rcx, (%rax)
leaq 0xdd89(%rip), %rax      # 0x15240
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
leaq 0xdd73(%rip), %rax      # 0x15240
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_case
Node *new_node_case(Node *const_expr, Node *body, Token *token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_CASE;
  node->lhs = const_expr;
  node->rhs = body;
  node->token = token;
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x21, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop