LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: bit_or
static Node *bit_or() {
  Node *lhs = bit_xor();
  Token *token;
  for (;;) {
    if ((token = match("|"))) {
      Node *node = new_node(NOR, token);
      node->lhs = lhs;
      node->rhs = bit_xor();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xb570
movq %rax, -0x8(%rbp)
leaq 0x7d8a(%rip), %rdi      # 0x132a2
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb55f
movq -0x10(%rbp), %rsi
movl $0x11, %edi
callq 0x9d10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb570
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb569
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0xb511
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: bit_xor
static Node *bit_xor() {
  Node *lhs = bit_and();
  Token *token;
  for (;;) {
    if ((token = match("^"))) {
      Node *node = new_node(NXOR, token);
      node->lhs = lhs;
      node->rhs = bit_and();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xb5e0
movq %rax, -0x8(%rbp)
leaq 0x7d1f(%rip), %rdi      # 0x132a7
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb5cf
movq -0x10(%rbp), %rsi
movl $0x12, %edi
callq 0x9d10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb5e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb5d9
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0xb581
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: bit_and
static Node *bit_and() {
  Node *lhs = equality();
  Token *token;
  for (;;) {
    if ((token = match("&"))) {
      Node *node = new_node(NAND, token);
      node->lhs = lhs;
      node->rhs = equality();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xb650
movq %rax, -0x8(%rbp)
leaq 0x7cad(%rip), %rdi      # 0x132a5
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb63f
movq -0x10(%rbp), %rsi
movl $0x10, %edi
callq 0x9d10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb650
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb649
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0xb5f1
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: equality
static Node *equality() {
  Node *lhs = relational();
  Token *tok;
  for (;;) {
    if ((tok = match("=="))) {
      Node *node = new_node(NEQ, tok);
      node->lhs = lhs;
      node->rhs = relational();
      lhs = node;
    } else if ((tok = match("!="))) {
      Node *node = new_node(NNE, tok);
      node->lhs = lhs;
      node->rhs = relational();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xb710
movq %rax, -0x8(%rbp)
leaq 0x7c41(%rip), %rdi      # 0x132a9
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb6af
movq -0x10(%rbp), %rsi
movl $0xc, %edi
callq 0x9d10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb710
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb709
leaq 0x7bf6(%rip), %rdi      # 0x132ac
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb6fd
movq -0x10(%rbp), %rsi
movl $0xd, %edi
callq 0x9d10
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb710
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb707
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0xb709
jmp 0xb661
nop
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: relational
static Node *relational() {
  Node *lhs = add();
  Token *tok;
  for (;;) {
    if ((tok = match("<"))) {
      Node *node = new_node(NLT, tok);
      node->lhs = lhs;
      node->rhs = add();
      lhs = node;
    } else if ((tok = match("<="))) {
      Node *node = new_node(NLE, tok);
      node->lhs = lhs;
      node->rhs = add();
      lhs = node;
    } else if ((tok = match(">"))) {
      Node *node = new_node(NGT, tok);
      node->lhs = lhs;
      node->rhs = add();
      lhs = node;
    } else if ((tok = match(">="))) {
      Node *node = new_node(NGE, tok);
      node->lhs = lhs;
      node->rhs = add();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0xb880
movq %rax, -0x8(%rbp)
leaq 0x7fbf(%rip), %rdi      # 0x136e7
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb772
movq -0x10(%rbp), %rsi
movl $0x8, %edi
callq 0x9d10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb880
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb86f
leaq 0x7f66(%rip), %rdi      # 0x136df
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb7c3
movq -0x10(%rbp), %rsi
movl $0x9, %edi
callq 0x9d10
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb880
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb86d
leaq 0x7af3(%rip), %rdi      # 0x132bd
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb811
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x9d10
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb880
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb86b
leaq 0x7ecb(%rip), %rdi      # 0x136e3
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb85f
movq -0x10(%rbp), %rsi
movl $0xb, %edi
callq 0x9d10
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb880
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb869
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
jmp 0xb86b
jmp 0xb86d
jmp 0xb86f
jmp 0xb721
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: add
static Node *add() {
  Node *lhs = mul();
  Token *tok;
  for (;;) {
    if ((tok = match("+"))) {
      Node *node = new_node(NADD, tok);
      node->lhs = lhs;
      node->rhs = mul();
      lhs = node;
    } else if ((tok = match("-"))) {
      Node *node = new_node(NSUB, tok);
      node->lhs = lhs;
      node->rhs = mul();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xb940
movq %rax, -0x8(%rbp)
leaq 0x7a28(%rip), %rdi      # 0x132c0
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb8df
movq -0x10(%rbp), %rsi
movl $0x3, %edi
callq 0x9d10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb940
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb939
leaq 0x79dd(%rip), %rdi      # 0x132c3
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb92d
movq -0x10(%rbp), %rsi
movl $0x4, %edi
callq 0x9d10
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb940
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb937
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0xb939
jmp 0xb891
nop
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: mul
static Node *mul() {
  Node *lhs = cast();
  Token *tok;
  for (;;) {
    if ((tok = match("*"))) {
      Node *node = new_node(NMUL, tok);
      node->lhs = lhs;
      node->rhs = cast();
      lhs = node;
    } else if ((tok = match("/"))) {
      Node *node = new_node(NDIV, tok);
      node->lhs = lhs;
      node->rhs = cast();
      lhs = node;
    } else if ((tok = match("%"))) {
      Node *node = new_node(NMOD, tok);
      node->lhs = lhs;
      node->rhs = cast();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0xba60
movq %rax, -0x8(%rbp)
leaq 0x7cf1(%rip), %rdi      # 0x13649
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb9a2
movq -0x10(%rbp), %rsi
movl $0x5, %edi
callq 0x9d10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xba60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xba4c
leaq 0x7ca3(%rip), %rdi      # 0x1364c
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb9f0
movq -0x10(%rbp), %rsi
movl $0x6, %edi
callq 0x9d10
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xba60
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xba4a
leaq 0x78b8(%rip), %rdi      # 0x132af
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xba3e
movq -0x10(%rbp), %rsi
movl $0x7, %edi
callq 0x9d10
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xba60
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xba48
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
jmp 0xba4a
jmp 0xba4c
jmp 0xb951
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: cast
static Node *cast() {
  if (eq_reserved(peek(0), "(") && is_typename(peek(1))) {
    Token *token = peek(0);
    consume();
    Type *type = type_specifier();
    while (match("*")) {
      type = ptr_to(type);
    }
    if (!match(")")) {
      parse_error(")", peek(0));
    }
    Node *node = new_node(NCAST, token);
    node->type = type;
    node->expr = cast();
    return node;
  } else {
    return unary();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rdi
leaq 0x7f53(%rip), %rsi      # 0x139ce
callq 0xfe80
testb $0x1, %al
jne 0xba89
jmp 0xbb42
movl $0x1, %edi
callq 0xa990
movq %rax, %rdi
callq 0xbb60
cmpl $0x0, %eax
je 0xbb42
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, -0x10(%rbp)
callq 0xa9e0
callq 0xaad0
movq %rax, -0x18(%rbp)
leaq 0x7b83(%rip), %rdi      # 0x13649
callq 0xa330
cmpq $0x0, %rax
je 0xbae0
movq -0x18(%rbp), %rdi
callq 0x9ed0
movq %rax, -0x18(%rbp)
jmp 0xbabf
leaq 0x781b(%rip), %rdi      # 0x13302
callq 0xa330
cmpq $0x0, %rax
jne 0xbb0a
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
leaq 0x77fd(%rip), %rdi      # 0x13302
callq 0xaa00
movq -0x10(%rbp), %rsi
movl $0x28, %edi
callq 0x9d10
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0xba60
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbb4b
callq 0xbc20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: is_typename
static int is_typename(Token *t) {
  if (eq_reserved(t, "struct")) {
    return 1;
  }

  if (eq_reserved(t, "enum")) {
    return 1;
  }

  if (t->tag == TIDENT || t->tag == TRESERVED) {
    for (TypeDef *td = typedefs; td != NULL; td = td->next) {
      if (streq(t->ident, td->name)) {
        return 1;
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x76d4(%rip), %rsi      # 0x1324b
callq 0xfe80
testb $0x1, %al
jne 0xbb82
jmp 0xbb8e
movl $0x1, -0x4(%rbp)
jmp 0xbc0e
movq -0x10(%rbp), %rdi
leaq 0x76e2(%rip), %rsi      # 0x1327b
callq 0xfe80
testb $0x1, %al
jne 0xbba4
jmp 0xbbad
movl $0x1, -0x4(%rbp)
jmp 0xbc0e
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0xbbc1
movq -0x10(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0xbc07
movq 0xbac8(%rip), %rax      # 0x17690
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbc05
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0xbbf6
movl $0x1, -0x4(%rbp)
jmp 0xbc0e
jmp 0xbbf8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xbbcc
jmp 0xbc07
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: new_subscript
static Node *new_subscript(Token *token, Node *value, Node *index) {
  Node *node = new_node(NDEREF, token);
  node->expr = new_node(NADD, token);
  node->expr->lhs = value;
  node->expr->rhs = index;
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movl $0x1a, %edi
callq 0x9d10
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movl $0x3, %edi
callq 0x9d10
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: find_var
static Node *find_var(Token *tok, char *name) {
  for (LVar *env = local_env; env != NULL; env = env->next) {
    if (streq(name, env->name)) {
      return new_var(tok, env->name, env->type, env->offset);
    }
  }

  for (GVar *env = global_env; env != NULL; env = env->next) {
    if (streq(name, env->name)) {
      return new_gvar(tok, env->name, env->type);
    }
  }

  for (Enum *env = enum_env; env != NULL; env = env->next) {
    if (streq(name, env->name)) {
      Node *val = clone_node(env->val);
      val->token = tok;
      return val;
    }
  }

  bad_token(tok, format("%s is not defined\n", name));
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0xb281(%rip), %rax      # 0x176a8
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc481
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0xc472
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movslq 0x18(%rax), %rcx
callq 0xc570
movq %rax, -0x8(%rbp)
jmp 0xc55e
jmp 0xc474
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc42b
movq 0xb200(%rip), %rax      # 0x17688
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc4da
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0xc4cb
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0xc5d0
movq %rax, -0x8(%rbp)
jmp 0xc55e
jmp 0xc4cd
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc48c
movq 0xb1bf(%rip), %rax      # 0x176a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xc538
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0xc529
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x9e10
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc55e
jmp 0xc52b
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xc4e5
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x6d7a(%rip), %rdi      # 0x132c5
movb $0x0, %al
callq 0xfa70
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xed90
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: new_var
static Node *new_var(Token *tok, char *name, Type *type, size_t offset) {
  Node *var = new_node(NVAR, tok);
  var->name = name;
  var->type = type;
  var->offset = offset;
  return var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movl $0x1, %edi
callq 0x9d10
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: new_gvar
static Node *new_gvar(Token *tok, char *name, Type *type) {
  Node *gvar = new_node(NGVAR, tok);
  gvar->name = name;
  gvar->type = type;
  return gvar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movl $0x2, %edi
callq 0x9d10
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: string
static Node *string() {
  Token *token = peek(0);

  char *str = expect(TSTRING, "string")->str;
  Vector *str_vec = new_vec();
  char *str_label = format(
      "Lstring%zu",
      str_count++); // TODO:
                    // -iオプションが渡されているかいないかでラベル名を変える

  for (char *c = str; *c != '\0'; c++) {
    vec_push(str_vec, new_int_node(token, *c));
  }
  vec_push(str_vec, new_int_node(token, 0));

  add_gvar(token, str_label, array_of(char_type(), strlen(str) + 1), NULL,
           str_vec);
  return find_var(token, str_label);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, -0x8(%rbp)
movl $0x1, %edi
leaq 0x6c97(%rip), %rsi      # 0x132d8
callq 0xb100
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movb $0x0, %al
callq 0x2280
movq %rax, -0x18(%rbp)
movq 0xb050(%rip), %rsi      # 0x176b0
movq %rsi, %rax
addq $0x1, %rax
movq %rax, 0xb042(%rip)      # 0x176b0
leaq 0x6c6a(%rip), %rdi      # 0x132df
movb $0x0, %al
callq 0xfa70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xc6c6
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movsbl (%rax), %esi
callq 0xb170
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x22e0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xc688
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xb170
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x22e0
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x9e70
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2070
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x9f10
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0xb1c0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc410
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: integer
static Node *integer() {
  Node *node = new_node(NINT, peek(0));
  node->integer = expect(TINT, "integer")->integer;
  node->type = int_type();
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
xorl %edi, %edi
callq 0x9d10
movq %rax, -0x8(%rbp)
xorl %edi, %edi
leaq 0x6b0a(%rip), %rsi      # 0x13282
callq 0xb100
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
callq 0x9e90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: comma
static Node *comma() {
  Node *lhs = assign();

  Token *tok;
  for (;;) {
    if ((tok = match(","))) {
      Node *node = new_node(NCOMMA, tok);
      node->lhs = lhs;
      node->rhs = assign();
      lhs = node;
    } else {
      return lhs;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xb240
movq %rax, -0x8(%rbp)
leaq 0x5876(%rip), %rdi      # 0x1204e
callq 0xa330
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xc81f
movq -0x10(%rbp), %rsi
movl $0x15, %edi
callq 0x9d10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xb240
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc829
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0xc7d1
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: add_lvar
static void add_lvar(Token *tok, char *name, Type *ty) {
  local_size += size_of(ty);
  LVar *lvar = calloc(sizeof(LVar), 1);
  lvar->name = name;
  lvar->type = ty;
  lvar->offset = local_size;
  lvar->next = local_env;
  local_env = lvar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9d60
addq 0xae64(%rip), %rax      # 0x176b8
movq %rax, 0xae5d(%rip)      # 0x176b8
movl $0x20, %edi
movl $0x1, %esi
callq 0x20d0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0xae2b(%rip), %rax      # 0x176b8
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq 0xae0b(%rip), %rcx      # 0x176a8
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, 0xadf9(%rip)      # 0x176a8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: declaration
static Node *declaration() {
  // variable definition
  Node *decl = declarator(type_specifier());
  add_lvar(decl->token, decl->name, decl->type);

  Token *tok;
  if ((tok = match("="))) {
    Node *comma = new_node(NCOMMA, tok);
    comma->lhs = decl;
    comma->rhs = read_initializer(tok, find_var(tok, decl->name));
    return comma;
  }

  return decl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0xaad0
movq %rax, %rdi
callq 0xb030
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0xc830
leaq 0x6240(%rip), %rdi      # 0x132ad
callq 0xa330
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xd0d4
movq -0x18(%rbp), %rsi
movl $0x15, %edi
callq 0x9d10
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0xc410
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xd0f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd0dc
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: read_initializer
static Node *read_initializer(Token *token, Node *var) {
  if (match("{")) {
    Node *init = read_init_list(token, var, 0);
    if (!match("}")) {
      parse_error("}", peek(0));
    }
    return init;
  } else {
    return new_assign_node(token, 0, var, assign());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x6154(%rip), %rdi      # 0x1325b
callq 0xa330
cmpq $0x0, %rax
je 0xd159
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0xd190
movq %rax, -0x20(%rbp)
leaq 0x606d(%rip), %rdi      # 0x13199
callq 0xa330
cmpq $0x0, %rax
jne 0xd14f
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
leaq 0x604f(%rip), %rdi      # 0x13199
callq 0xaa00
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd184
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xb240
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
xorl %esi, %esi
callq 0xb380
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: read_init_list
static Node *read_init_list(Token *token, Node *var, int i) {
  Node *node = new_assign_node(
      token, 0, new_subscript(token, var, new_int_node(token, i)), assign());
  if (eq_reserved(peek(0), "}")) {
    Node *comma = new_node(NCOMMA, token);
    comma->lhs = node;
    comma->rhs = var;
    return comma;
  }
  if (!match(",")) {
    parse_error(",", peek(0));
  }
  Node *comma = new_node(NCOMMA, token);
  comma->lhs = node;
  comma->rhs = read_init_list(token, var, i + 1);
  return comma;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xb170
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0xc160
movq %rax, -0x40(%rbp)
callq 0xb240
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
xorl %esi, %esi
callq 0xb380
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rdi
leaq 0x5f90(%rip), %rsi      # 0x13199
callq 0xfe80
testb $0x1, %al
jne 0xd214
jmp 0xd248
movq -0x10(%rbp), %rsi
movl $0x15, %edi
callq 0x9d10
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd2b6
leaq 0x4dff(%rip), %rdi      # 0x1204e
callq 0xa330
cmpq $0x0, %rax
jne 0xd272
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
leaq 0x4de1(%rip), %rdi      # 0x1204e
callq 0xaa00
movq -0x10(%rbp), %rsi
movl $0x15, %edi
callq 0x9d10
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
addl $0x1, %edx
callq 0xd190
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/parse.c
// Function: expr_stmt
static Node *expr_stmt() {
  Node *node = new_node(NEXPR_STMT, peek(0));
  node->expr = expr();
  if (!match(";")) {
    parse_error("expr stmt: ;", peek(0));
  }
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
movl $0x1c, %edi
callq 0x9d10
movq %rax, -0x8(%rbp)
callq 0xc7b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
leaq 0x6060(%rip), %rdi      # 0x13359
callq 0xa330
cmpq $0x0, %rax
jne 0xd31c
xorl %eax, %eax
movl %eax, %edi
callq 0xa990
movq %rax, %rsi
leaq 0x6058(%rip), %rdi      # 0x1336f
callq 0xaa00
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/regalloc.c
// Function: scan
void scan(Vector* regs) {
  IReg** used = calloc(NUM_REGS, sizeof(IReg*));

  for (int i = 0; i < regs->length; i++) {
    IReg* reg = regs->ptr[i];
    bool found = false;

    for (int i = 0; i < NUM_REGS - 1; i++) {
      if (!(used[i] && reg->def < used[i]->last_use)) {
        assert(i < NUM_REGS);
        reg->real_reg = i;
        used[i] = reg;
        found = true;
        break;
      }
    }

    if (!found) {
      used[NUM_REGS - 1] = reg;
      int k = choose_to_spill(used);
      reg->real_reg = k;
      used[k]->real_reg = NUM_REGS - 1;
      used[k]->spill = true;
      used[k] = reg;
      error("error: register allocation %s\n", show_ireg(reg));
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x7, %edi
movl $0x8, %esi
callq 0x20d0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xd489
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x6, -0x28(%rbp)
jge 0xd406
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xd3b3
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl 0x14(%rcx), %eax
jl 0xd3f9
cmpl $0x7, -0x28(%rbp)
jge 0xd3bb
jmp 0xd3da
leaq 0x5fba(%rip), %rdi      # 0x1337c
leaq 0x5fc0(%rip), %rsi      # 0x13389
movl $0x5e, %edx
leaq 0x5fc3(%rip), %rcx      # 0x13398
callq 0x20b0
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movb $0x1, -0x21(%rbp)
jmp 0xd406
jmp 0xd3fb
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xd386
testb $0x1, -0x21(%rbp)
jne 0xd479
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0xd490
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x6, (%rax)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movb $0x1, 0x18(%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdi
callq 0x8ec0
movq %rax, %rsi
leaq 0x5f3a(%rip), %rdi      # 0x133ac
movb $0x0, %al
callq 0xfb50
jmp 0xd47b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd356
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/regalloc.c
// Function: choose_to_spill
static int choose_to_spill(IReg **used) {
  int k = 0;
  for (int i = 1; i < NUM_REGS; i++) {
    if (used[k]->last_use < used[i]->last_use) {
      k = i;
    }
  }
  return k;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
cmpl $0x7, -0x10(%rbp)
jge 0xd4df
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x14(%rax), %eax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl 0x14(%rcx), %eax
jge 0xd4d2
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xd4d4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd4a6
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/regalloc.c
// Function: alloc_regs
void alloc_regs(IProgram* prog) {
  for (int i = 0; i < prog->ifuncs->length; i++) {
    IFunc* func = prog->ifuncs->ptr[i];
    if (func->blocks) {
      Vector* regs = collect_regs(func);
      scan(regs);

      for (int i = 0; i < regs->length; i++) {
        eprintf("%s ", show_ireg(regs->ptr[i]));
      }
      eprintf("\n");
    } 

    // TODO: Reserve stack area to spilled register

    // TODO: Convert accesses to spilled registers to load and stores
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0xd5b2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xd5a2
movq -0x18(%rbp), %rdi
callq 0xd5c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd330
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xd594
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8ec0
movq %rax, %rsi
leaq 0x5e49(%rip), %rdi      # 0x133cb
movb $0x0, %al
callq 0xfc00
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd556
leaq 0x60a1(%rip), %rdi      # 0x1363c
movb $0x0, %al
callq 0xfc00
jmp 0xd5a4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd503
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/regalloc.c
// Function: collect_regs
static Vector* collect_regs(IFunc* func) {
  int ic = 0;
  Vector* regs = new_vec();

  for (int i = 0; i < func->blocks->length; i++) {
    Block* block = func->blocks->ptr[i];
    three_to_two(block);

    for (int j = 0; j < block->instrs->length; j++, ic++) {
      IR* inst = block->instrs->ptr[j];
      set_def(inst->r0, ic);
      set_last_use(inst->r1, ic);
      set_last_use(inst->r2, ic);

      if (inst->args) {
        for (size_t i = 0; i < inst->args->length; i++) {
          set_last_use(inst->args->ptr[i], ic);
        }
      }

      if (inst->r0 && !collected(regs, inst->r0)) {
        vec_push(regs, inst->r0);
      }
    }
  }

  return regs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movb $0x0, %al
callq 0x2280
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0xd729
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xd740
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0xd719
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xd830
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xd860
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xd860
movq -0x38(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xd6cf
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x50(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0xd6cd
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
callq 0xd860
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xd692
jmp 0xd6cf
movq -0x38(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd700
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xd890
testb $0x1, %al
jne 0xd700
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x22e0
jmp 0xd702
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd622
jmp 0xd71b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd5e5
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/regalloc.c
// Function: three_to_two
static void three_to_two(Block* block) {
  Vector* v = new_vec();

  for (size_t i = 0; i < block->instrs->length; i++) {
    IR* inst = block->instrs->ptr[i];

    if (inst->r0 && inst->r1 && inst->r2) {
      IR* ir2 = new_ir(IMOV);
      ir2->r0 = inst->r0;
      ir2->r1 = inst->r1;
      vec_push(v, ir2);
      inst->r1 = inst->r0;
    }
    vec_push(v, inst);
  }

  block->instrs = v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x2280
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0xd816
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd7f8
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xd7f8
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd7f8
movl $0x16, %edi
callq 0x8d70
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x22e0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22e0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xd75f
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/regalloc.c
// Function: collected
static bool collected(Vector* regs, IReg* reg) {
  for (size_t i = 0; i < regs->length; i++) {
    IReg* elem = regs->ptr[i];
    if (reg->id == elem->id) {
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xd8eb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0xd8db
movb $0x1, -0x1(%rbp)
jmp 0xd8ef
jmp 0xd8dd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd8a4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/sema.c
// Function: sema
void sema(Program* prog) {
  for (GVar* gvar = prog->globals; gvar != NULL; gvar = gvar->next) {
    walk(gvar->init);
    if (gvar->inits != NULL) {
      for (size_t i = 0; i < gvar->inits->length; i++) {
        walk(gvar->inits->ptr[i]);
      }
    }
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd988
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xda10
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd979
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0xd977
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xda10
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xd93f
jmp 0xd979
jmp 0xd97b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xd918
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x9d2a(%rip)      # 0x176c0
movb $0x0, %al
callq 0x2280
movq %rax, 0x9d24(%rip)      # 0x176c8
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0xd9fb
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd9eb
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xda10
jmp 0xd9ed
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd9ac
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/sema.c
// Function: arith_conv
static Type* arith_conv(Type* t1, Type* t2) {
  Type* type = NULL;

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

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

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

  return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x5, (%rax)
je 0xe9ca
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
jne 0xe9d8
leaq 0x4abc(%rip), %rdi      # 0x1348d
movb $0x0, %al
callq 0xfb50
movq -0x8(%rbp), %rdi
callq 0x9d60
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9d60
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jb 0xea04
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xea0c
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xea30
movq -0x18(%rbp), %rdi
callq 0x9dd0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/sema.c
// Function: is_assignable
static int is_assignable(Type* lhs, Type* rhs) {
  if (lhs->ty == TY_STRUCT || rhs->ty == TY_STRUCT) {
    return false;
  } else {
    return (lhs->ty == rhs->ty) || (is_integer_type(lhs) && is_integer_type(rhs));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
je 0xeac2
movq -0x18(%rbp), %rax
cmpl $0x5, (%rax)
jne 0xeacb
movl $0x0, -0x4(%rbp)
jmp 0xeb16
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rdx
movb $0x1, %al
cmpl (%rdx), %ecx
movb %al, -0x19(%rbp)
je 0xeb0b
movq -0x10(%rbp), %rdi
callq 0xe6e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
je 0xeb05
movq -0x18(%rbp), %rdi
callq 0xe6e0
cmpl $0x0, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/sema.c
// Function: ret_type
static Type* ret_type(char* name) {
  for (size_t i = 0; i < funcs->length; i++) {
    Function* fn = funcs->ptr[i];
    if (streq(name, fn->name)) {
      return fn->ret_type;
    }
  }
  eprintf("undefined function %s\n", name);
  return int_type();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8b81(%rip), %rcx      # 0x176c0
cmpq 0x10(%rcx), %rax
jae 0xeb8e
movq 0x8b74(%rip), %rax      # 0x176c0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0xeb7e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xeba9
jmp 0xeb80
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xeb34
movq -0x10(%rbp), %rsi
leaq 0x4907(%rip), %rdi      # 0x134a0
movb $0x0, %al
callq 0xfc00
callq 0x9e90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/token.c
// Function: print_line
static void print_line(char* start, char* pos) {
  size_t line = 0;
  size_t column = 0;
  /* char* start = src; // 出力する行の先頭文字 */

  for (char *c = start; c != pos && *c != '\0'; c++) {
    if (*c == '\n') {
      start = c + 1;
      line++;
      column = 0;
    } else {
      column++;
    }
  }

  eprintf("error at (%d, %d)\n\n", line + 1, column + 1);

  // 行を出力
  size_t len = strchr(start, '\n') - start;
  eprintf("%.*s\n", len, start);

  // posまでインデントする
  for (size_t i = 0; i < column; i++) {
    if (start[i] == '\t') {
      eprintf("\t");
    } else {
      eprintf(" ");
    }
  }

  eprintf("^\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x39(%rbp)
je 0xec87
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xec90
jmp 0xecda
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xecbe
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
jmp 0xecca
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xeccc
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xec68
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
leaq 0x4939(%rip), %rdi      # 0x1362a
movb $0x0, %al
callq 0xfc00
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x2080
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq 0x491e(%rip), %rdi      # 0x1363e
movb $0x0, %al
callq 0xfc00
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xed78
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0xed5a
leaq 0x346c(%rip), %rdi      # 0x121bd
movb $0x0, %al
callq 0xfc00
jmp 0xed68
leaq 0x34c2(%rip), %rdi      # 0x12223
movb $0x0, %al
callq 0xfc00
jmp 0xed6a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xed2f
leaq 0x48c5(%rip), %rdi      # 0x13644
movb $0x0, %al
callq 0xfc00
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/token.c
// Function: lex
Token* lex(char* path) {
  FILE* file = fopen(path, "r");
  if (file == NULL) {
    error("cannot open file: %s\n", path);
  }

  src = read_file(file);
  fclose(file);
  cur = src;

  Token* current = next_token();
  Token* head = current;

  while ((current->next = next_token()) != NULL) {
    current = current->next;
  }

  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x443f(%rip), %rsi      # 0x13216
callq 0x2130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xedf9
movq -0x8(%rbp), %rsi
leaq 0x4822(%rip), %rdi      # 0x13614
movb $0x0, %al
callq 0xfb50
movq -0x10(%rbp), %rdi
callq 0xee60
movq %rax, 0x88cf(%rip)      # 0x176d8
movq -0x10(%rbp), %rdi
callq 0x2060
movq 0x88bf(%rip), %rax      # 0x176d8
movq %rax, 0x88c0(%rip)      # 0x176e0
callq 0xeeb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xeeb0
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xee50
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xee31
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/token.c
// Function: read_file
static char* read_file(FILE* file) {
  StringBuilder* sb = new_sb();

  char c;
  while ((c = fgetc(file)) != EOF) {
    sb_putc(sb, c);
  }
  return sb_run(sb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0xfcd0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20c0
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0xee98
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0xfd30
jmp 0xee75
movq -0x10(%rbp), %rdi
callq 0xfe20
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)