LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: postfix
static Node *postfix() {
  Token *tk;
  Node *node = compound_literal();
  if (node) {
    return node;
  }

  node = primary();
  for (;;) {
    if (tk = consume("[")) {
      node = new_bin_node(ND_DEREF, new_add_node(node, expr(), tk), NULL, tk);
      expect("]");
      continue;
    }

    if (consume(".")) {
      node = struct_ref(node);
      continue;
    }

    if (tk = consume("->")) {
      // x->y == (*x).y なので nodeをderefしたうえで . と同じ結果を返す
      node = new_unary_node(ND_DEREF, node, tk);
      node = struct_ref(node);
      continue;
    }

    if (tk = consume("++")) {
      node = new_unary_node(ND_POST_INC, node, tk);
      continue;
    }

    if (tk = consume("--")) {
      node = new_unary_node(ND_POST_DEC, node, tk);
      continue;
    }

    break;
  }
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x9230
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8ff5
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9123
callq 0xa890
movq %rax, -0x18(%rbp)
leaq 0x785b(%rip), %rdi      # 0x10860
callq 0x6780
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x9058
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xae60
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x8620
movq %rax, %rsi
movq -0x10(%rbp), %rcx
movl $0x1f, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x8140
movq %rax, -0x18(%rbp)
leaq 0x66e5(%rip), %rdi      # 0xf736
callq 0x7730
jmp 0x8ffe
leaq 0x7a9e(%rip), %rdi      # 0x10afd
callq 0x6780
cmpq $0x0, %rax
je 0x9079
movq -0x18(%rbp), %rdi
callq 0x9130
movq %rax, -0x18(%rbp)
jmp 0x8ffe
leaq 0x7853(%rip), %rdi      # 0x108d3
callq 0x6780
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x90b7
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x1f, %edi
callq 0x8a80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9130
movq %rax, -0x18(%rbp)
jmp 0x8ffe
leaq 0x77c9(%rip), %rdi      # 0x10887
callq 0x6780
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x90e8
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x26, %edi
callq 0x8a80
movq %rax, -0x18(%rbp)
jmp 0x8ffe
leaq 0x779b(%rip), %rdi      # 0x1088a
callq 0x6780
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x9119
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x27, %edi
callq 0x8a80
movq %rax, -0x18(%rbp)
jmp 0x8ffe
jmp 0x911b
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: struct_ref
static Node *struct_ref(Node *lhs) {
  add_type(lhs);

  if (lhs->ty->kind != TY_STRUCT) {
    fprintf(stderr, "type_info: %s\n", type_info(lhs->ty));
    error_at(token->str, "not a struct(lhs->ty->kind: %d", lhs->ty->kind);
  }

  Token *tok = token;
  Member *m = find_member(lhs->ty, expect_ident());
  if (!m) {
    error_at(tok->str, "no such member");
  }

  Node *n = new_unary_node(ND_MEMBER, lhs, tok);
  n->member = m;

  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdb80
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x9, (%rax)
je 0x91a8
movq 0xbe9f(%rip), %rax      # 0x14ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x47b0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x7887(%rip), %rsi      # 0x10a02
movb $0x0, %al
callq 0x2100
leaq 0xc447(%rip), %rax      # 0x155d0
movq (%rax), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %edx
leaq 0x7870(%rip), %rsi      # 0x10a11
movb $0x0, %al
callq 0x6370
leaq 0xc421(%rip), %rax      # 0x155d0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x79d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xadd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x91f4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x7843(%rip), %rsi      # 0x10a30
movb $0x0, %al
callq 0x6370
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x23, %edi
callq 0x8a80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: compound_literal
static Node *compound_literal() {
  Token *tmp = token;
  if (!consume("(") || !is_type(token)) {
    token = tmp;
    return NULL;
  }
  Type *ty = type_name();
  expect(")");

  if(!peek_token("{")) {
    token = tmp;
    return NULL;
  }

  tmp = token;
  if (scope_depth == 0) {
    // 無名のグローバル変数追加
    Var *var = new_gvar(new_label(), ty, true, false);
    var->initializer = gvar_initializer(ty);
    return new_var_node(var, tmp);
  } else {
    // 無名のローカル変数追加
    Var *var = new_lvar(new_label(), ty);
    Node *node = new_var_node(var, tmp);
    node->init = local_var_initializer(var, tmp);
    return node;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0xc391(%rip), %rax      # 0x155d0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x72b5(%rip), %rdi      # 0x10502
callq 0x6780
cmpq $0x0, %rax
je 0x926b
leaq 0xc371(%rip), %rax      # 0x155d0
movq (%rax), %rdi
callq 0x6fc0
testb $0x1, %al
jne 0x9286
movq -0x10(%rbp), %rcx
leaq 0xc35a(%rip), %rax      # 0x155d0
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x9366
callq 0x8a40
movq %rax, -0x18(%rbp)
leaq 0x7377(%rip), %rdi      # 0x1060d
callq 0x7730
leaq 0x6fee(%rip), %rdi      # 0x10290
callq 0x69d0
testb $0x1, %al
jne 0x92c6
movq -0x10(%rbp), %rcx
leaq 0xc31a(%rip), %rax      # 0x155d0
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x9366
leaq 0xc303(%rip), %rax      # 0x155d0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0xc2a5(%rip)      # 0x15580
jne 0x9320
callq 0x9620
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x9370
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9400
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6930
movq %rax, -0x8(%rbp)
jmp 0x9366
callq 0x9620
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x9430
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6930
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x94a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: new_gvar
static Var *new_gvar(char *name, Type *type, bool emit, bool is_static) {
  Var *var = new_var(name, type, false);
  var->is_static = is_static;
  if (emit) {
    // 通常のグローバル変数や、文字列リテラルは.dataセクションに出力するように
    // VarListとして保存するが、関数定義などのND_CALLのときのチェックようにしか使わないものは
    // (new_varの中でやっている)スコープにのみいれて、
    // emit: false で呼び出してコード生成時に何も出力しないようにする。
    VarList *v = calloc(1, sizeof(VarList));
    v->var = var;
    v->next = globals;
    globals = v;
  }

  return var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x9520
movq %rax, -0x20(%rbp)
movb -0x12(%rbp), %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
testb $0x1, -0x11(%rbp)
je 0x93ed
movl $0x1, %edi
movl $0x10, %esi
callq 0x20e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0xc19d(%rip), %rcx      # 0x15578
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, 0xc18b(%rip)      # 0x15578
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: new_lvar
static Var *new_lvar(char *name, Type *type) {
  Var *var = new_var(name, type, true);

  VarList *v = calloc(1, sizeof(VarList));
  v->var = var;
  v->next = locals;

  // fprintf(stderr, "new_lvar:next ... %s\n", locals ? "nanika" : "NULL");
  locals = v;

  return var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x9520
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x20e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0xc124(%rip), %rcx      # 0x155a0
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, 0xc112(%rip)      # 0x155a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: local_var_initializer
static Node *local_var_initializer(Var *var, Token *tk) {
  Node head = {};
  local_var_initializer_sub(&head, var, var->type, NULL);

  Node *node = new_node(ND_BLOCK, tk);
  node->body = head.next;

  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xd8(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x20c0
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq -0xd8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
callq 0xa0f0
movq -0x10(%rbp), %rsi
movl $0x1a, %edi
callq 0x6980
movq %rax, -0xe0(%rbp)
movq -0xa8(%rbp), %rcx
movq -0xe0(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0xe0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: new_var
static Var *new_var(char *name, Type *type, bool is_local) {
  Var *var = calloc(1, sizeof(Var));
  var->type = type;
  var->name = name;
  var->is_local = is_local;

  // 今のscopeにこの変数を追加
  push_var_scope(name, var);

  return var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x20e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9590
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: push_var_scope_helper
static VarScope *push_var_scope_helper(char *name) {
  VarScope *sc = calloc(1, sizeof(VarScope));

  sc->name = name;
  sc->next = var_scope;
  sc->depth = scope_depth;
  var_scope = sc;

  return sc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x20e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0xbf9e(%rip), %rcx      # 0x15590
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl 0xbf81(%rip), %ecx      # 0x15580
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xbf7f(%rip)      # 0x15590
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: new_init_val
static Initializer *new_init_val(Initializer *cur, int sz, long val) {
  Initializer *initializer = calloc(1, sizeof(Initializer));
  initializer->val = val;
  initializer->sz = sz;
  cur->next = initializer;
  return initializer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x20e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: is_array_limit_over
static bool is_array_limit_over(Type *ty, int i) {
  if (ty->is_incomplete) {
    // サイズが不定の場合は無制限にする
    return false;
  }
  return i >= ty->array_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0xc(%rax)
je 0x9b3b
movb $0x0, -0x1(%rbp)
jmp 0x9b4f
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
setge %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: emit_struct_padding
static Initializer *emit_struct_padding(Initializer *cur, Type *parent, Member *mem) {
  // padding領域の開始位置
  int a = mem->offset + mem->ty->size;
  // padding領域の終了位置(最後のメンバーの場合、構造体の最後の領域までをパッディングとする
  int b = mem->next ? mem->next->offset : parent->size;
  int padding_size = b - a; // a, b はそれぞれ上の説明の A, Bのこと。例でいうと b = 4, a = (0 + 1) = 1 となって b - a が 3になり3バイト分ゼロで初期化する
  cur = new_init_zero(cur, padding_size);
  return cur;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
addl 0x4(%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9c22
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x9c2c
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x9b90
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/pocari[P]compilerbook-9cc/parser.c
// Function: new_init_label
static Initializer *new_init_label(Initializer *cur, char *label, long addend) {
  Initializer *initializer = calloc(1, sizeof(Initializer));
  initializer->label = label;
  initializer->addend = addend;
  cur->next = initializer;
  return initializer;
}

// 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 $0x28, %esi
callq 0x20e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: skip_excess_elements2
static void skip_excess_elements2() {
  for (;;) {
    if (consume("{")) {
      skip_excess_elements2();
    } else {
      // brace以外の場合は何か式があるはずなので読み飛ばす
      assign();
    }
    if (consume_end()) {
      return;
    }
    expect(",");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x9cc6
leaq 0x65c3(%rip), %rdi      # 0x10290
callq 0x6780
cmpq $0x0, %rax
je 0x9cdf
callq 0x9cc0
jmp 0x9ce4
callq 0x9d00
callq 0x6700
testb $0x1, %al
jne 0x9cef
jmp 0x9cf1
popq %rbp
retq
leaq 0x68f9(%rip), %rdi      # 0x105f1
callq 0x7730
jmp 0x9cc6
nop
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: lvar_init_zero
static Node *lvar_init_zero(Node *cur, Var *var, Type *ty, Designator *dseg) {
  if (ty->kind == TY_ARRAY) {
    // 配列の場合は各要素も再帰的に0にする
    for (int i = 0; i < ty->array_size; i++) {
      Designator desg2 = {dseg, i};
      cur = lvar_init_zero(cur, var, ty->ptr_to, &desg2);
    }
    return cur;
  }
  // 配列でない場合は、単純にその変数(入れ子の配列の場合はどこかの末端の要素)に0を代入するコードをnextにつなげていく
  cur->next = new_desg_node(var, dseg, new_num_node(0, token));
  return cur->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x8, (%rax)
jne 0xa6fe
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0xa6f4
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq -0x48(%rbp), %rcx
callq 0xa680
movq %rax, -0x10(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa6a8
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa748
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0xaebb(%rip), %rax      # 0x155d0
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x8f90
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0xa610
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: new_desg_node_sub
static Node *new_desg_node_sub(Var *var, Designator *desg, Token *tk) {
  if (!desg) {
    return new_var_node(var, tk);
  }
  Node *node = new_desg_node_sub(var, desg->next, tk);
  if (desg->mem) {
    // dsegが構造体のメンバー参照なら、返ってきたnodeを構造体の変数とみなしてそのメンバー参照のastを作成
    node = new_unary_node(ND_MEMBER, node, tk);
    node->member = desg->mem;

    return node;
  }

  node = new_add_node(node, new_num_node(desg->idx, tk), tk);

  node = new_unary_node(ND_DEREF, node, tk);
  add_type(node);

  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa7d1
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6930
movq %rax, -0x8(%rbp)
jmp 0xa87b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xa7a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xa827
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x23, %edi
callq 0x8a80
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa87b
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x8f90
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x8620
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1f, %edi
callq 0x8a80
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xdb80
movq -0x28(%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/pocari[P]compilerbook-9cc/parser.c
// Function: primary
static Node *primary() {
  if (consume("(")) {
    Node *node = expr();
    expect(")");
    return node;
  }

  Token *t = consume_ident();
  if (t) {
    if (consume("(")) {
      // identに続けて"("があったら関数呼び出し
      return parse_call_func(t);
    } else {
      // "("がなかったら変数参照
      return parse_var(t);
    }
  }

  t = consume_kind(TK_STR);
  if (t) {
    return parse_string_literal(t);
  }

  // () でも ident でもなければ 整数
  t = token;
  return new_num_node(expect_number(), t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x5c63(%rip), %rdi      # 0x10502
callq 0x6780
cmpq $0x0, %rax
je 0xa8cc
callq 0xae60
movq %rax, -0x10(%rbp)
leaq 0x5d53(%rip), %rdi      # 0x1060d
callq 0x7730
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa953
callq 0x7630
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa90c
leaq 0x5c1f(%rip), %rdi      # 0x10502
callq 0x6780
cmpq $0x0, %rax
je 0xa8fd
movq -0x18(%rbp), %rdi
callq 0xa960
movq %rax, -0x8(%rbp)
jmp 0xa953
movq -0x18(%rbp), %rdi
callq 0xab30
movq %rax, -0x8(%rbp)
jmp 0xa953
movl $0x14, %edi
callq 0x7060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa930
movq -0x18(%rbp), %rdi
callq 0xabd0
movq %rax, -0x8(%rbp)
jmp 0xa953
leaq 0xac99(%rip), %rax      # 0x155d0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0xad60
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x8f90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: parse_var
static Node *parse_var(Token *t) {
  VarScope *sc = find_var(t);
  if (!sc) {
    error_at(t->str, "変数 %s は宣言されていません。",
             my_strndup(t->str, t->len));
  }
  if (sc->enum_ty) {
    return new_num_node(sc->enum_val, t);
  } else {
    return new_var_node(sc->var, t);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xac50
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xab85
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x6690
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x5e3c(%rip), %rsi      # 0x109ba
movb $0x0, %al
callq 0x6370
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xaba7
movq -0x18(%rbp), %rax
movslq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x8f90
movq %rax, -0x8(%rbp)
jmp 0xabbc
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6930
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/pocari[P]compilerbook-9cc/parser.c
// Function: parse_string_literal
static Node *parse_string_literal(Token *str_token) {
  Type *ty = array_of(char_type, str_token->content_length);
  Var *var = new_gvar(new_label(), ty, true, true);
  var->initializer = new_init_string(str_token->contents, str_token->content_length);

  return new_var_node(var, str_token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xa905(%rip), %rax      # 0x154e8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %esi
callq 0xda20
movq %rax, -0x10(%rbp)
callq 0x9620
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x9370
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %esi
callq 0xacf0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x6930
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: find_var
static VarScope *find_var(Token *token) {
  for (VarScope *sc = var_scope; sc; sc = sc->next) {
    if (sc->type_def) {
      // typedef は変数じゃないので無視
      continue;
    }

    if (strlen(sc->name) == token->len &&
        strncmp(sc->name, token->str, token->len) == 0) {
      return sc;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xa92d(%rip), %rax      # 0x15590
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xacd0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xac7b
jmp 0xacc3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2090
movq -0x10(%rbp), %rcx
movslq 0x20(%rcx), %rcx
cmpq %rcx, %rax
jne 0xacc1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x20(%rax), %rdx
callq 0x2060
cmpl $0x0, %eax
jne 0xacc1
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xacd8
jmp 0xacc3
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xac67
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: new_init_string
static Initializer *new_init_string(char *p, int len) {
  Initializer head = {};
  Initializer *cur = &head;
  for (int i = 0; i < len; i++) {
    cur = new_init_val(cur, 1, p[i]);
  }
  return head.next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20c0
leaq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xad50
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsbq (%rax,%rcx), %rdx
movl $0x1, %esi
callq 0x9ac0
movq %rax, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xad1e
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: expect_number
static long expect_number() {
  if (token->kind != TK_NUM) {
    error_at(token->str, "数ではありません。");
  }
  long val = token->val;
  token = token->next;

  return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xa861(%rip), %rax      # 0x155d0
movq (%rax), %rax
cmpl $0x3, (%rax)
je 0xad93
leaq 0xa852(%rip), %rax      # 0x155d0
movq (%rax), %rax
movq 0x18(%rax), %rdi
leaq 0x5c5a(%rip), %rsi      # 0x109e6
movb $0x0, %al
callq 0x6370
leaq 0xa836(%rip), %rax      # 0x155d0
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0xa824(%rip), %rax      # 0x155d0
movq (%rax), %rax
movq 0x8(%rax), %rcx
leaq 0xa816(%rip), %rax      # 0x155d0
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: find_member
static Member *find_member(Type *type, char *name) {
  assert(type->kind == TY_STRUCT);

  for (Member *m = type->members; m ; m = m->next) {
    if (strcmp(m->name, name) == 0) {
      return m;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x9, (%rax)
jne 0xadeb
jmp 0xae0a
leaq 0x5c4d(%rip), %rdi      # 0x10a3f
leaq 0x57fa(%rip), %rsi      # 0x105f3
movl $0x950, %edx            # imm = 0x950
leaq 0x5c52(%rip), %rcx      # 0x10a57
callq 0x20b0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xae4c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0xae3d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xae54
jmp 0xae3f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xae16
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: expr
static Node *expr() {
  Token *tk;
  Node *node = assign();

  while (tk = consume(",")) {
    // カンマがある場合、最後の式の値だけスタックに積みたいので、
    // カンマより左にある式の結果は全部式文(ND_EXPR_STMT)にして計算だけして結果は捨てる
    node = new_unary_node(ND_EXPR_STMT, node, node->tok);
    node = new_bin_node(ND_COMMA, node, assign(), tk);
  }

  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x9d00
movq %rax, -0x10(%rbp)
leaq 0x5779(%rip), %rdi      # 0x105f1
callq 0x6780
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0xaec9
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0x21, %edi
callq 0x8a80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x9d00
movq -0x18(%rbp), %rsi
movq %rax, %rdx
movq -0x8(%rbp), %rcx
movl $0x25, %edi
callq 0x8140
movq %rax, -0x10(%rbp)
jmp 0xae71
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: global_var_decl
static void global_var_decl() {
  StorageClass sclass = false;
  Type *type = basetype(&sclass);

  if (consume(";")) {
    // int; とかの場合
    return;
  }

  char *ident_name;
  Token *tk = token;
  type = declarator(type, &ident_name);

  if (sclass == TYPEDEF) {
    expect(";");
    push_typedef_scope(ident_name, type);
    return;
  }

  // extern が設定sれていない場合はこのファイルで領域を確保する
  // それ以外はどこかのファイルのコンパイルで領域が確保されているはずなので、名前のみ登録
  Var *var = new_gvar(ident_name, type, sclass != EXTERN, sclass == STATIC);
  if (sclass == EXTERN) {
    // extern の場合初期化式は書けず、宣言のみになる
    expect(";");
    return;
  }
  if (!consume("=")) {
    if (type->is_incomplete) {
      error_at(tk->str, "incomplete element type(gvar)");
    }
    expect(";");
    return;
  }
  var->initializer = gvar_initializer(type);
  expect(";");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x4(%rbp), %rdi
callq 0x6b40
movq %rax, -0x10(%rbp)
leaq 0x570c(%rip), %rdi      # 0x1060f
callq 0x6780
cmpq $0x0, %rax
je 0xaf13
jmp 0xaff5
leaq 0xa6b6(%rip), %rax      # 0x155d0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6ef0
movq %rax, -0x10(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0xaf56
leaq 0x56d0(%rip), %rdi      # 0x1060f
callq 0x7730
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb000
jmp 0xaff5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
cmpl $0x4, -0x4(%rbp)
setne %cl
cmpl $0x2, -0x4(%rbp)
sete %al
movzbl %cl, %edx
andl $0x1, %edx
movzbl %al, %ecx
andl $0x1, %ecx
callq 0x9370
movq %rax, -0x28(%rbp)
cmpl $0x4, -0x4(%rbp)
jne 0xaf95
leaq 0x5681(%rip), %rdi      # 0x1060f
callq 0x7730
jmp 0xaff5
leaq 0x58ba(%rip), %rdi      # 0x10856
callq 0x6780
cmpq $0x0, %rax
jne 0xafd5
movq -0x10(%rbp), %rax
testb $0x1, 0xc(%rax)
je 0xafc7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x5b1d(%rip), %rsi      # 0x10add
movb $0x0, %al
callq 0x6370
leaq 0x5641(%rip), %rdi      # 0x1060f
callq 0x7730
jmp 0xaff5
movq -0x10(%rbp), %rdi
callq 0x9400
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq 0x561f(%rip), %rdi      # 0x1060f
callq 0x7730
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: function_def_or_decl
static Function *function_def_or_decl() {
  // 今からパースする関数ようにグローバルのlocalsを初期化
  locals = NULL;

  StorageClass sclass;
  Type *ret_type = basetype(&sclass);
  char *ident;
  ret_type = declarator(ret_type, &ident);
  Function *func = calloc(1, sizeof(Function));
  func->return_type = ret_type;
  func->name = ident;
  // 関数呼び出し時のチェック用に定義した関数も関数型としてscopeに入れる
  // is_staticに関して、関数は関数自体で別途is_staticを持っていて、そちらで .global の出力有無を制御しているので、このgvarのis_statciは何でもよい
  new_gvar(func->name, func_type(func->return_type), false, false);

  Scope *sc = enter_scope();
  expect("(");
  function_params(func);

  // ")" の後に ; が来てたら関数の定義なしで宣言のみ
  if (consume(";")) {
    leave_scope(sc);
    return NULL;
  }
  expect("{");

  // 関数本体
  int i = 0;
  Node head = {};
  Node *cur = &head;
  // fprintf(stderr, "parse function body start\n");
  while (!consume("}")) {
    cur->next = stmt();
    cur = cur->next;
  }
  // fprintf(stderr, "parse function body end\n");
  func->body = head.next;
  func->locals = locals;
  func->is_staitc = (sclass == STATIC);
  set_stack_info(func);

  leave_scope(sc);
  return func;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq $0x0, 0xa55a(%rip) # 0x155a0
leaq -0xc(%rbp), %rdi
callq 0x6b40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6ef0
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x20e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x110(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xda80
movq -0x110(%rbp), %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x9370
callq 0xb1d0
movq %rax, -0x30(%rbp)
leaq 0x5434(%rip), %rdi      # 0x10502
callq 0x7730
movq -0x28(%rbp), %rdi
callq 0xb230
leaq 0x552c(%rip), %rdi      # 0x1060f
callq 0x6780
cmpq $0x0, %rax
je 0xb104
movq -0x30(%rbp), %rdi
callq 0xb3f0
movq $0x0, -0x8(%rbp)
jmp 0xb1c3
leaq 0x5185(%rip), %rdi      # 0x10290
callq 0x7730
movl $0x0, -0x34(%rbp)
leaq -0x100(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x20c0
leaq -0x100(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq 0x5163(%rip), %rdi      # 0x102a2
callq 0x6780
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb153
jmp 0xb17a
callq 0xb4d0
movq %rax, %rcx
movq -0x108(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x108(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x108(%rbp)
jmp 0xb138
movq -0xd0(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0xa410(%rip), %rcx      # 0x155a0
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpl $0x2, -0xc(%rbp)
sete %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x34(%rax)
movq -0x28(%rbp), %rdi
callq 0xb430
movq -0x30(%rbp), %rdi
callq 0xb3f0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: enter_scope
static Scope *enter_scope(void) {
  Scope *new_scope = calloc(1, sizeof(Scope));

  new_scope->var_scope = var_scope;
  new_scope->tag_scope = tag_scope;
  scope_depth++;

  return new_scope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x10, %esi
callq 0x20e0
movq %rax, -0x8(%rbp)
movq 0xa39e(%rip), %rcx      # 0x15590
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq 0xa388(%rip), %rcx      # 0x15588
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl 0xa372(%rip), %eax      # 0x15580
addl $0x1, %eax
movl %eax, 0xa369(%rip)      # 0x15580
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: set_stack_info
static void set_stack_info(Function *f) {
  // vaargの場合引数のregister、6個を保存する場所＋ ... までの引数の個数情報をわたす1個で合計 (6+1)*8 = 56byteのオフセットを準備
  int offset = f->has_vararg ? 56 : 0;
  for (VarList *v = f->locals; v; v = v->next) {
    Var *var = v->var;
    offset = align_to(offset, var->type->align);
    offset += var->type->size;
    var->offset = offset;
  }
  f->stack_size = align_to(offset, 8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x35(%rax), %dl
xorl %eax, %eax
movl $0x38, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb4ae
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %esi
callq 0x75f0
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xb45f
movl -0xc(%rbp), %edi
movl $0x8, %esi
callq 0x75f0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: static_var_decl_sub
static void static_var_decl_sub(Type *base, StorageClass sclass) {
  while (consume(",")) {
    Token *tmp_tk = token;
    char *ident_name;
    Type *type = declarator(base, &ident_name);
    Var *var = new_gvar(new_label(), type, true, sclass == STATIC);
    push_var_scope(ident_name, var);

    if (!consume("=")) {
      if (type->is_incomplete) {
        error_at(tmp_tk->str, "incomplete element type(gvar)");
      }
      continue;
    }
    var->initializer = gvar_initializer(type);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x470b(%rip), %rdi      # 0x105f1
callq 0x6780
cmpq $0x0, %rax
je 0xbf98
leaq 0x96d4(%rip), %rax      # 0x155d0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6ef0
movq %rax, -0x28(%rbp)
callq 0x9620
movq %rax, %rdi
movq -0x28(%rbp), %rsi
cmpl $0x2, -0xc(%rbp)
sete %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x1, %edx
callq 0x9370
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9590
leaq 0x4907(%rip), %rdi      # 0x10856
callq 0x6780
cmpq $0x0, %rax
jne 0xbf7f
movq -0x28(%rbp), %rax
testb $0x1, 0xc(%rax)
je 0xbf7a
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x4b6a(%rip), %rsi      # 0x10add
movb $0x0, %al
callq 0x6370
jmp 0xbedf
movq -0x28(%rbp), %rdi
callq 0x9400
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xbedf
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: var_decl_sub
static Node *var_decl_sub(Type *base, Node *decl) {
  while (consume(",")) {
    Token *tk = token;
    char *ident_name;
    Type *type = declarator(base, &ident_name);

    Var *var = new_lvar(ident_name, type);
    Node *node = new_node(ND_VAR_DECL, tk);
    node->var = var;

    if (var->type->kind == TY_VOID) {
      error_at(tk->str, "void型の変数は宣言できません");
    }

    // 初期化式があるかどうかチェック
    if (tk = consume("=")) {
      // 今作ったlocal変数に初期化式の値を代入するノードを設定
      node->initializer = local_var_initializer(var, tk);
    }

    if (type->is_incomplete) {
      error_at(tk->str, "incomplete element type(var_decl_sub)");
    }

    decl = new_bin_node(ND_COMMA, decl, node, tk);
  }
  return decl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x463a(%rip), %rdi      # 0x105f1
callq 0x6780
cmpq $0x0, %rax
je 0xc0a3
leaq 0x9603(%rip), %rax      # 0x155d0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6ef0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9430
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movl $0x20, %edi
callq 0x6980
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0xc036
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x4b18(%rip), %rsi      # 0x10b47
movb $0x0, %al
callq 0x6370
leaq 0x4819(%rip), %rdi      # 0x10856
callq 0x6780
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xc064
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x94a0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x28(%rbp), %rax
testb $0x1, 0xc(%rax)
je 0xc084
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x4b15(%rip), %rsi      # 0x10b92
movb $0x0, %al
callq 0x6370
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x25, %edi
callq 0x8140
movq %rax, -0x10(%rbp)
jmp 0xbfb0
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/parser.c
// Function: read_expr_stmt
static Node *read_expr_stmt() {
  Node *node = new_node(ND_EXPR_STMT, token);
  node->kind = ND_EXPR_STMT;
  node->lhs = expr();
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x9511(%rip), %rax      # 0x155d0
movq (%rax), %rsi
movl $0x21, %edi
callq 0x6980
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x21, (%rax)
callq 0xae60
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/string_buffer.c
// Function: sb_init
string_buffer *sb_init() {
  string_buffer *sb = calloc(1, sizeof(string_buffer));

  sb->str_len = 0;
  sb->buf_len = 16;
  sb->buf = calloc(sb->buf_len, sizeof(char));

  return sb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x10, %esi
callq 0x20e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x10, 0xc(%rax)
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rdi
movl $0x1, %esi
callq 0x20e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/test_func.c
// Function: alloc_3num_ary_8_byte_cell
void alloc_3num_ary_8_byte_cell(int **p) {
  int *lp = *p = (void *)calloc(4, 8);

  lp[0] = 2;
  lp[1] = 3;
  lp[2] = 4;
  lp[3] = 5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x4, %edi
movl $0x8, %esi
callq 0x20e0
movq -0x8(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rax
movl $0x3, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x4, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x5, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/test_func.c
// Function: add_all1
int add_all1(int x, ...) {
  va_list ap;
  va_start(ap, x);

  for (;;) {
    int y = va_arg(ap, int);
    if (y == 0)
      return x;
    x += y;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
testb %al, %al
je 0xc3f8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movl %edi, -0x4(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0xc47d
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0xc49a
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xc4b8
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movl -0x24(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc442
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/test_func.c
// Function: add_all2
int add_all2(int x, int y, ...) {
  va_list ap;
  va_start(ap, y);
  x = x + y;

  for (;;) {
    int y = va_arg(ap, int);
    if (y == 0)
      return x;
    x += y;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
testb %al, %al
je 0xc508
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0xc592
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0xc5af
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xc5cd
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movl -0x24(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc557
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: new_token
Token *new_token(TokenKind kind, Token *cur, char *str, int len) {
  Token *tok = calloc(1, sizeof(Token));
  tok->kind = kind;
  tok->str = str;
  tok->len = len;
  cur->next = tok;
  return tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x20e0
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: dump_token
void dump_token(Token *t) {
  if (!t) {
    printf("## (NULL token)");
    return;
  }

  printf("## (Token kind: %*s ", 12 ,token_kind_to_s(t->kind));

  switch (t->kind) {
    case TK_NUM:
      printf("[%ld]", t->val);
      break;
    case TK_STR:
      printf("[contents: [%s], length(includes \\0): %d", t->contents, t->content_length);
      break;
    default:
      printf("[%s]", my_strndup(t->str, t->len));
      break;
  }
  printf(")\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xc896
leaq 0x4530(%rip), %rdi      # 0x10dba
movb $0x0, %al
callq 0x20a0
jmp 0xc93b
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0xc640
movq %rax, %rdx
leaq 0x451f(%rip), %rdi      # 0x10dca
xorl %eax, %eax
movl $0xc, %esi
callq 0x20a0
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x3, %eax
je 0xc8d1
jmp 0xc8c7
movl -0xc(%rbp), %eax
subl $0x14, %eax
je 0xc8e9
jmp 0xc908
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x3999(%rip), %rdi      # 0x10279
movb $0x0, %al
callq 0x20a0
jmp 0xc92d
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %edx
leaq 0x44e0(%rip), %rdi      # 0x10ddf
movb $0x0, %al
callq 0x20a0
jmp 0xc92d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x6690
movq %rax, %rsi
leaq 0x44e2(%rip), %rdi      # 0x10e08
movb $0x0, %al
callq 0x20a0
leaq 0x44d9(%rip), %rdi      # 0x10e0d
movb $0x0, %al
callq 0x20a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: free_tokens
void free_tokens(Token *cur) {
  while (cur) {
    Token *tmp = cur->next;
    free(cur);
    cur  = tmp;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc982
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc95c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: is_alnum
bool is_alnum(char c) {
  return
    ('a' <= c && c <= 'z') ||
    ('A' <= c && c <= 'Z') ||
    ('0' <= c && c <= '9') ||
    (c == '_');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0xc9b5
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x7a, %ecx
movb %al, -0x2(%rbp)
jle 0xc9f8
movsbl -0x1(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0xc9d0
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x5a, %ecx
movb %al, -0x2(%rbp)
jle 0xc9f8
movsbl -0x1(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0xc9eb
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x39, %ecx
movb %al, -0x2(%rbp)
jle 0xc9f8
movsbl -0x1(%rbp), %eax
cmpl $0x5f, %eax
sete %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: is_ident_first_char
bool is_ident_first_char(char c) {
  return
    ('a' <= c && c <= 'z') ||
    ('A' <= c && c <= 'Z') ||
    (c == '_');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0xca25
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x7a, %ecx
movb %al, -0x2(%rbp)
jle 0xca4d
movsbl -0x1(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0xca40
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x5a, %ecx
movb %al, -0x2(%rbp)
jle 0xca4d
movsbl -0x1(%rbp), %eax
cmpl $0x5f, %eax
sete %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)