LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: get_ptr_if_array
Node *get_ptr_if_array(Node *node) {
  if (!node) return NULL;
  if (is_array(type(node))) {
    return new_node_expr(ND_ADDR, node, NULL, node->token);
  } else {
    return node;
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x549c
movq %rdi, %rbx
callq 0x9610
movq %rax, %rdi
callq 0x919f
testb %al, %al
je 0x549e
movq 0x50(%rbx), %rcx
pushq $0x16
popq %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
jmp 0x54df
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_expr
Node *new_node_expr(NodeKind kind, Node *lhs, Node *rhs, Token *op_token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = kind;
  node->lhs = lhs;
  node->rhs = rhs;
  node->token = op_token;
  // node->type = type(node);
  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
callq 0x10d0
movl %ebp, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x50(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_member
Node *new_node_member(Node *lhs, Token *ident) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_MEMBER;
  node->lhs = lhs;
  node->token = ident;
  Type *ty = type(lhs);
  if (!is_struct(ty))
    error_at_node(lhs, "The expression must have a struct or union type.");
  MemberInfo *mem = get_member_type(ty, ident);
  if (!mem) error_at_token(ident, "The member does not exists in the struct.");
  node->offset = mem->offset;
  node->type = mem->type;
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
callq 0x10d0
movq %rax, %rbx
movl $0x1b, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x50(%rax)
movq %r15, %rdi
callq 0x9610
movq %rax, %r12
movq %rax, %rdi
callq 0x91ad
testb %al, %al
jne 0x5567
leaq 0x5d7c(%rip), %rsi      # 0xb2d9
movq %r15, %rdi
xorl %eax, %eax
callq 0x4a9e
movq %r12, %rdi
movq %r14, %rsi
callq 0x55a9
movq %rax, %r15
testq %rax, %rax
jne 0x558b
leaq 0x5d89(%rip), %rsi      # 0xb30a
movq %r14, %rdi
xorl %eax, %eax
callq 0x48b3
movl 0x18(%r15), %eax
movl %eax, 0x38(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: get_member_type
MemberInfo *get_member_type(Type *type, Token *ident) {
  if (!is_struct(type)) error_at_token(ident, "Not a struct.");
  MemberInfo *member;
  if (!type->tag_name) {
    if (!type->member)
      error_at_token(ident, "No tag name and the type has no member.");
    member = type->member;
  } else {
    TagName *tag = find_tag(type->tag_name);
    if (!tag) error_at_token(ident, "Undefined tag name.");
    member = tag->type->member;
  }

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x91ad
testb %al, %al
jne 0x55ce
leaq 0x5ddb(%rip), %rsi      # 0xb39f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x48b3
movq 0x30(%r15), %rdi
testq %rdi, %rdi
je 0x55ff
callq 0x5cca
movq %rax, %r14
testq %rax, %rax
jne 0x55f5
leaq 0x5dea(%rip), %rsi      # 0xb3d5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x48b3
movq 0x10(%r14), %r14
addq $0x20, %r14
jmp 0x561b
leaq 0x20(%r15), %r14
cmpq $0x0, 0x20(%r15)
jne 0x561b
leaq 0x5d9c(%rip), %rsi      # 0xb3ad
movq %rbx, %rdi
xorl %eax, %eax
callq 0x48b3
movq (%r14), %r14
testq %r14, %r14
je 0x5633
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x5a72
testb %al, %al
je 0x561b
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_node
Node *new_node(NodeKind kind, Token *op_token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = kind;
  node->token = op_token;
  return node;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
callq 0x10d0
movl %ebp, (%rax)
movq %rbx, 0x50(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_cast
Node *new_node_cast(Node *lhs, Type *type, Token *op_token) {
  Node *node = new_node(ND_CAST, op_token);
  node->type = type;
  node->lhs = lhs;
  return node;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
callq 0x10d0
movl $0x1a, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x48(%rax)
movq %rbx, 0x50(%rax)
movq 0x58(%r15), %rcx
movq %rcx, 0x58(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_if_then
Node *new_node_if_then(Node *cond_, Node *then_, Node *else_) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_IF;
  node->lhs = cond_;
  node->rhs = then_;
  node->xhs = else_;
  node->token = token;
  return node;
}

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

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

  return lvar;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x10d0
movq %rax, %r14
movq %r15, 0x8(%rax)
movq %rbx, %rdi
callq 0x929b
movl %eax, %ebp
testl %eax, %eax
jne 0x57a4
xorl %eax, %eax
callq 0x4427
leaq 0x5be4(%rip), %rsi      # 0xb37e
movq %r15, %rdi
xorl %eax, %eax
callq 0x48b3
leaq 0xba9d(%rip), %rax      # 0x11248
movq (%rax), %rcx
testq %rcx, %rcx
je 0x57b8
addl 0x18(%rcx), %ebp
jmp 0x57d1
movq 0xbab1(%rip), %rdx      # 0x11270
movq 0x10(%rdx), %rdx
cmpb $0x1, 0x38(%rdx)
jne 0x57ce
subl $-0x80, %ebp
jmp 0x57d1
addl $0x20, %ebp
movl %ebp, 0x18(%r14)
movq %rbx, 0x10(%r14)
movq %rcx, (%r14)
movq %r14, (%rax)
leaq 0xba6a(%rip), %rax      # 0x11250
movq (%rax), %rcx
movq %rcx, 0x20(%r14)
movq %r14, (%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_case
Node *new_node_case(Node *const_expr, Node *body, Token *token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_CASE;
  node->lhs = const_expr;
  node->rhs = body;
  node->token = token;
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
callq 0x10d0
movl $0x21, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x50(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_default
Node *new_node_default(Node *body, Token *token) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_DEFAULT;
  node->lhs = body;
  node->token = token;
  return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
callq 0x10d0
movl $0x22, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x50(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_while
Node *new_node_while(Node *cond_, Node *do_) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_WHILE;
  node->lhs = cond_;
  node->rhs = do_;
  node->token = token;
  return node;
}

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
callq 0x10d0
movl $0x26, (%rax)
movq %rbx, 0x48(%rax)
leaq 0xb90c(%rip), %rcx      # 0x11228
movq (%rcx), %rcx
movq %rcx, 0x50(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_fdecl
Node *new_node_fdecl(Token *name, Vector *params, int max_offset, Node *body,
                     Type *type) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_FDECL;
  node->lhs = body;
  node->nodes = params;
  node->offset = max_offset;
  node->token = name;
  node->type = type;
  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
callq 0x10d0
movl $0x27, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x48(%rax)
movl %ebp, 0x38(%rax)
movq %r12, 0x50(%rax)
movq %rbx, 0x58(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: consume_number
long consume_number() {
  if (token->kind != TK_NUM) {
    error_at_token(token, "Unexpected token: Number is expected.");
  }
  int num = token->num_val;
  token = token->next;
  return num;
}

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x5b2f
movq %rdi, %r14
leaq 0xb751(%rip), %r15      # 0x11260
xorl %ebx, %ebx
movq (%r15), %r15
testq %r15, %r15
je 0x5b31
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x5a72
testb %al, %al
je 0x5b11
movq 0x8(%r15), %rbx
jmp 0x5b31
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: find_lvar
LVar *find_lvar(Token *token) {
  for (LVar *var = scope; var; var = var->scope) {
    if (cmp_token(var->token, token)) {
      return var;
    }
  }
  return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xb708(%rip), %rbx      # 0x11250
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x5b66
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x5a72
testb %al, %al
jne 0x5b66
addq $0x20, %rbx
jmp 0x5b48
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: find_lvar_in_scope
bool find_lvar_in_scope(Token *token) {
  for (LVar *var = scope; var; var = var->scope) {
    if (var->scope_head) return false;
    if (cmp_token(var->token, token)) {
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb6d1(%rip), %rcx      # 0x11250
movq (%rcx), %r14
testq %r14, %r14
je 0x5ba8
cmpb $0x0, 0x28(%r14)
jne 0x5ba6
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x5a72
leaq 0x20(%r14), %rcx
testb %al, %al
je 0x5b7f
movb $0x1, %cl
jmp 0x5ba8
xorl %ecx, %ecx
testq %r14, %r14
setne %al
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_gvar
Global *new_gvar(Token *ident, Type *type) {
  Global *global = calloc(1, sizeof(Global));
  global->next = globals;
  global->token = ident;
  global->type = type;
  globals = global;
  return global;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x10d0
leaq 0xb65c(%rip), %rcx      # 0x11230
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_func
Function *new_func(Token *ident, Type *type, Node *body) {
  Function *func = calloc(1, sizeof(Function));
  func->next = functions;
  func->token = ident;
  func->type = type;
  func->body = body;
  functions = func;
  return func;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x10d0
leaq 0xb62a(%rip), %rcx      # 0x11268
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_tag
TagName *new_tag(Token *ident, Type *type) {
  if (!ident) return NULL;
  TagName *tag = calloc(1, sizeof(TagName));
  type->tag_name = ident;
  tag->next = tagnames;
  tag->ident = ident;
  tag->type = type;
  tagnames = tag;
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5cf7
movq %rdi, %r14
leaq 0xb57b(%rip), %rbx      # 0x11258
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x5cf7
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x5a72
testb %al, %al
je 0x5cdd
jmp 0x5cf9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_typedef
Typedef *new_typedef(Token *ident, Type *type) {
  if (!ident) return NULL;
  Typedef *tdef = calloc(1, sizeof(Typedef));
  tdef->next = tdef_names;
  tdef->ident = ident;
  tdef->type = type;
  tdef_names = tdef;
}

// Assembly:
testq %rdi, %rdi
je 0x5d3d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10d0
leaq 0xb53b(%rip), %rcx      # 0x11260
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x8(%rax)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: new_member_info
MemberInfo *new_member_info(Token *ident, Type *type) {
  MemberInfo *ty_ident = calloc(1, sizeof(MemberInfo));
  ty_ident->type = type;
  ty_ident->ident = ident;
  return ty_ident;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x10d0
movq %rbx, 0x10(%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: pointer_add
Node *pointer_add(Node *ptr, Node *offset, Token *token) {
  offset = new_node_binary(ND_MUL, offset,
                           new_node_num(sizeof_type(type(ptr)->ptr_to), token),
                           token);
  return new_node_binary(ND_ADD, ptr, offset, token);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x9610
movq 0x8(%rax), %rdi
callq 0x929b
movslq %eax, %rdi
movq %rbx, %rsi
callq 0x5200
pushq $0x6
popq %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x5422
pushq $0x4
popq %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x5422
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_unary_expr
Node *parse_unary_expr() {
  Token *op_token = token;
  if (consume_if(TK_ADD)) {
    return parse_cast_expr();
  } else if (consume_if(TK_SUB)) {
    Node *node = parse_cast_expr();
    if (node->kind == ND_NUM) {
      node->num_val = -(node->num_val);
      return node;
    } else {
      return new_node_binary(ND_SUB, new_node_num(0, token), node, op_token);
    }
  } else if (consume_if(TK_AND)) {
    return new_node_expr(ND_ADDR, parse_cast_expr(), NULL, op_token);
  } else if (consume_if(TK_MUL)) {
    Node *node = parse_cast_expr();
    return new_node_binary(ND_DEREF, node, NULL, op_token);
  } else if (consume_if(TK_SIZEOF)) {
    Type *ty;
    if (peek(TK_OP_PAREN) && is_type_specifier(token->next)) {
      expect(TK_OP_PAREN);
      ty = parse_decl(false)->type;
      expect(TK_CL_PAREN);
    } else {
      ty = type(parse_unary_expr());
    }
    return new_node_num(sizeof_type(ty), op_token);
  } else if (consume_if(TK_NOT)) {
    Node *node = new_node(ND_NOT, op_token);
    node->lhs = parse_cast_expr();
    node->type = new_type_int();
    return node;
  } else if (consume_if(TK_TILDA)) {
    Node *node = new_node(ND_CMP, op_token);
    node->lhs = parse_cast_expr();
    node->type = new_type_int();
    return node;
  } else {
    return parse_postfix_expr();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xae6b(%rip), %r15      # 0x11228
movq (%r15), %rbx
movl (%rbx), %eax
cmpl $0x33, %eax
je 0x6464
cmpl $0x4, %eax
je 0x64ba
cmpl $0x5, %eax
je 0x64a4
cmpl $0x16, %eax
je 0x6406
cmpl $0x19, %eax
je 0x6432
cmpl $0x27, %eax
je 0x6427
cmpl $0x3, %eax
jne 0x649a
movq 0x8(%rbx), %rax
movq %rax, (%r15)
popq %rbx
popq %r14
popq %r15
jmp 0x6560
movq 0x8(%rbx), %rax
movq %rax, (%r15)
callq 0x6560
pushq $0x16
popq %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x54df
movq 0x8(%rbx), %rax
movq %rax, (%r15)
pushq $0x14
jmp 0x643b
movq 0x8(%rbx), %rax
movq %rax, (%r15)
pushq $0xe
popq %rdi
movq %rbx, %rsi
callq 0x563c
movq %rax, %r14
callq 0x6560
movq %rax, 0x8(%r14)
xorl %eax, %eax
callq 0x9084
movq %rax, 0x58(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rax
movq %rax, (%r15)
cmpl $0x1d, (%rax)
jne 0x64d4
movq 0x8(%rax), %rdi
callq 0x5ad3
testb %al, %al
je 0x64d4
pushq $0x1d
popq %rdi
callq 0x5a46
xorl %edi, %edi
callq 0x651c
movq 0x10(%rax), %r14
pushq $0x1e
popq %rdi
callq 0x5a46
jmp 0x64e4
popq %rbx
popq %r14
popq %r15
jmp 0x6015
movq 0x8(%rbx), %rax
movq %rax, (%r15)
callq 0x6560
pushq $0x17
popq %rdi
movq %rax, %rsi
xorl %edx, %edx
jmp 0x650f
movq 0x8(%rbx), %rax
movq %rax, (%r15)
callq 0x6560
movq %rax, %r14
cmpl $0x1, (%rax)
jne 0x64fc
negq 0x20(%r14)
jmp 0x645b
callq 0x63b1
movq %rax, %rdi
callq 0x9610
movq %rax, %r14
movq %r14, %rdi
callq 0x929b
movslq %eax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x5200
movq (%r15), %rsi
xorl %edi, %edi
callq 0x5200
pushq $0x5
popq %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x5422
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_decl
MemberInfo *parse_decl(bool allow_undefined_tag) {
  // declaration-specifiers
  if (!is_type_specifier(token))
    error_at_token(token, "Expected type specifier or typedef name.");

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xacff(%rip), %rax      # 0x11228
movq (%rax), %r14
movq %r14, %rdi
callq 0x5ad3
testb %al, %al
jne 0x6549
leaq 0x51e4(%rip), %rsi      # 0xb723
movq %r14, %rdi
xorl %eax, %eax
callq 0x48b3
movzbl %bl, %edi
callq 0x7604
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x718e
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_cast_expr
Node *parse_cast_expr() {
  if (peek(TK_OP_PAREN) && is_type_specifier(token->next)) {
    expect(TK_OP_PAREN);
    Token *op_token = token;
    MemberInfo *info = parse_decl(false);
    expect(TK_CL_PAREN);
    Node *node = new_node_cast(parse_cast_expr(), info->type, op_token);
    return node;
  }
  return parse_unary_expr();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xacbd(%rip), %rbx      # 0x11228
movq (%rbx), %rax
cmpl $0x1d, (%rax)
jne 0x65b8
movq 0x8(%rax), %rdi
callq 0x5ad3
testb %al, %al
je 0x65b8
pushq $0x1d
popq %rdi
callq 0x5a46
movq (%rbx), %rbx
xorl %edi, %edi
callq 0x651c
movq %rax, %r14
pushq $0x1e
popq %rdi
callq 0x5a46
callq 0x6560
movq 0x10(%r14), %rsi
movq %rax, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x565c
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x63b1
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_mul_expr
Node *parse_mul_expr() {
  Node *lhs = parse_cast_expr();
  Node *rhs;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6560
movq %rax, %rbx
leaq 0xac4a(%rip), %r15      # 0x11228
pushq $0x6
popq %r12
pushq $0x7
popq %r13
movq (%r15), %r14
movl (%r14), %eax
movl %r12d, %ebp
cmpl $0x5, %eax
je 0x65fc
cmpl $0x6, %eax
jne 0x661d
movl %r13d, %ebp
movq 0x8(%r14), %rax
movq %rax, (%r15)
callq 0x6560
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x54a3
movq %rax, %rbx
jmp 0x65e6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_add_expr
Node *parse_add_expr() {
  Node *lhs = parse_mul_expr();
  Node *rhs;
  while (true) {
    Token *op_token = token;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x65c4
movq %rax, %r14
leaq 0xabdf(%rip), %r13      # 0x11228
pushq $0x5
popq %rbx
pushq $0x4
popq %rbp
movq (%r13), %r15
movl (%r15), %eax
cmpl $0x4, %eax
je 0x66af
cmpl $0x3, %eax
jne 0x6787
movq 0x8(%r15), %rax
movq %rax, (%r13)
callq 0x65c4
movq %rax, %r12
movq %r14, %rdi
callq 0x9610
movq %rax, %rdi
callq 0x9198
testb %al, %al
je 0x672d
movq %r12, %rdi
callq 0x9610
movq %rax, %rdi
callq 0x91e8
testb %al, %al
je 0x672d
movq %r14, %rdi
movq %r12, %rsi
jmp 0x675b
movq 0x8(%r15), %rax
movq %rax, (%r13)
callq 0x65c4
movq %rax, %r12
movq %r14, %rdi
callq 0x9610
movq %rax, %rdi
callq 0x9198
testb %al, %al
je 0x66ef
movq %r12, %rdi
callq 0x9610
movq %rax, %rdi
callq 0x91e8
testb %al, %al
je 0x66ef
movq %r14, %rdi
movq %r12, %rsi
jmp 0x671d
movq %r14, %rdi
callq 0x9610
movq %rax, %rdi
callq 0x9198
testb %al, %al
je 0x676b
movq %r12, %rdi
callq 0x9610
movq %rax, %rdi
callq 0x91e8
testb %al, %al
je 0x676b
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5fc7
movq %rax, %r14
jmp 0x664f
movq %r14, %rdi
callq 0x9610
movq %rax, %rdi
callq 0x91e8
testb %al, %al
je 0x676f
movq %r12, %rdi
callq 0x9610
movq %rax, %rdi
callq 0x9198
testb %al, %al
je 0x676f
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5f79
movq %rax, %r14
jmp 0x664f
movl %ebx, %edi
jmp 0x6771
movl %ebp, %edi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x5422
movq %rax, %r14
jmp 0x664f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_shift_expr
Node *parse_shift_expr() {
  Node *lhs = parse_add_expr();
  Node *rhs;
  while (true) {
    Token *op_token = token;
    if (consume_if(TK_SHR)) {
      rhs = parse_add_expr();
      lhs = new_node_binary_arith(ND_SHR, lhs, rhs, op_token);
      continue;
    } else if (consume_if(TK_SHL)) {
      rhs = parse_add_expr();
      lhs = new_node_binary_arith(ND_SHL, lhs, rhs, op_token);
      continue;
    }
    return lhs;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x662f
movq %rax, %rbx
leaq 0xaa75(%rip), %r15      # 0x11228
pushq $0x12
popq %r12
pushq $0x13
popq %r13
movq (%r15), %r14
movl (%r14), %eax
movl %r12d, %ebp
cmpl $0x1a, %eax
je 0x67d1
cmpl $0x1b, %eax
jne 0x67f2
movl %r13d, %ebp
movq 0x8(%r14), %rax
movq %rax, (%r15)
callq 0x662f
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x54a3
movq %rax, %rbx
jmp 0x67bb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_rel_expr
Node *parse_rel_expr() {
  Node *lhs = parse_shift_expr();
  for (;;) {
    Token *op_token = token;
    if (consume_if(TK_GE)) {
      lhs = new_node_binary(ND_GE, lhs, parse_shift_expr(), op_token);
      continue;
    } else if (consume_if(TK_GT)) {
      lhs = new_node_binary(ND_GT, lhs, parse_shift_expr(), op_token);
      continue;
    } else if (consume_if(TK_LE)) {
      lhs = new_node_binary(ND_GE, parse_shift_expr(), lhs, op_token);
      continue;
    } else if (consume_if(TK_LT)) {
      lhs = new_node_binary(ND_GT, parse_shift_expr(), lhs, op_token);
      continue;
    }
    return lhs;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6799
movq %rax, %r14
leaq 0xaa0a(%rip), %r12      # 0x11228
leaq 0x49d3(%rip), %r13      # 0xb1f8
pushq $0xb
popq %rbx
pushq $0xa
popq %rbp
movq (%r12), %r15
movl (%r15), %eax
addl $-0x9, %eax
cmpl $0x3, %eax
ja 0x689f
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq 0x8(%r15), %rax
movq %rax, (%r12)
callq 0x6799
movl %ebx, %edi
jmp 0x688c
movq 0x8(%r15), %rax
movq %rax, (%r12)
callq 0x6799
movl %ebx, %edi
jmp 0x6875
movq 0x8(%r15), %rax
movq %rax, (%r12)
callq 0x6799
movl %ebp, %edi
movq %rax, %rsi
movq %r14, %rdx
jmp 0x6892
movq 0x8(%r15), %rax
movq %rax, (%r12)
callq 0x6799
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5422
movq %rax, %r14
jmp 0x682b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_eq_expr
Node *parse_eq_expr() {
  Node *node = parse_rel_expr();
  for (;;) {
    Token *op_token = token;
    if (consume_if(TK_EQ)) {
      node = new_node_binary(ND_EQ, node, parse_rel_expr(), op_token);
      continue;
    } else if (consume_if(TK_NEQ)) {
      node = new_node_binary(ND_NEQ, node, parse_rel_expr(), op_token);
      continue;
    }
    return node;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6804
movq %rax, %rbx
leaq 0xa95d(%rip), %r15      # 0x11228
pushq $0x8
popq %r12
pushq $0x9
popq %r13
movq (%r15), %r14
movl (%r14), %eax
movl %r12d, %ebp
cmpl $0x7, %eax
je 0x68e9
cmpl $0x8, %eax
jne 0x690a
movl %r13d, %ebp
movq 0x8(%r14), %rax
movq %rax, (%r15)
callq 0x6804
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x5422
movq %rax, %rbx
jmp 0x68d3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_and_expr
Node *parse_and_expr() {
  Node *node = parse_eq_expr();
  for (;;) {
    Token *op_token = token;
    if (consume_if(TK_AND)) {
      node = new_node_binary_arith(ND_AND, node, parse_eq_expr(), op_token);
      continue;
    }
    return node;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x68b1
movq %rax, %r14
leaq 0xa8f5(%rip), %r12      # 0x11228
pushq $0xf
popq %rbx
movq (%r12), %r15
cmpl $0x16, (%r15)
jne 0x6962
movq 0x8(%r15), %rax
movq %rax, (%r12)
callq 0x68b1
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x54a3
movq %rax, %r14
jmp 0x6936
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_xor_expr
Node *parse_xor_expr() {
  Node *node = parse_and_expr();
  for (;;) {
    Token *op_token = token;
    if (consume_if(TK_XOR)) {
      node = new_node_binary_arith(ND_XOR, node, parse_and_expr(), op_token);
      continue;
    }
    return node;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x691c
movq %rax, %r14
leaq 0xa8a0(%rip), %r12      # 0x11228
pushq $0x11
popq %rbx
movq (%r12), %r15
cmpl $0x18, (%r15)
jne 0x69b7
movq 0x8(%r15), %rax
movq %rax, (%r12)
callq 0x691c
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x54a3
movq %rax, %r14
jmp 0x698b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_or_expr
Node *parse_or_expr() {
  Node *node = parse_xor_expr();
  for (;;) {
    Token *op_token = token;
    if (consume_if(TK_OR)) {
      node = new_node_binary_arith(ND_OR, node, parse_xor_expr(), op_token);
      continue;
    }
    return node;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x6971
movq %rax, %r14
leaq 0xa84b(%rip), %r12      # 0x11228
pushq $0x10
popq %rbx
movq (%r12), %r15
cmpl $0x17, (%r15)
jne 0x6a0c
movq 0x8(%r15), %rax
movq %rax, (%r12)
callq 0x6971
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x54a3
movq %rax, %r14
jmp 0x69e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_land_expr
Node *parse_land_expr() {
  Node *node = parse_or_expr();
  for (;;) {
    Token *op_token = token;
    if (consume_if(TK_LAND)) {
      node = new_node_binary(ND_LAND, node, parse_or_expr(), op_token);
      continue;
    }
    return node;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x69c6
movq %rax, %r14
leaq 0xa7f6(%rip), %r12      # 0x11228
pushq $0xc
popq %rbx
movq (%r12), %r15
cmpl $0x14, (%r15)
jne 0x6a61
movq 0x8(%r15), %rax
movq %rax, (%r12)
callq 0x69c6
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5422
movq %rax, %r14
jmp 0x6a35
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_lor_expr
Node *parse_lor_expr() {
  Node *node = parse_land_expr();
  for (;;) {
    Token *op_token = token;
    if (consume_if(TK_LOR)) {
      node = new_node_binary(ND_LOR, node, parse_land_expr(), op_token);
      continue;
    }
    return node;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x6a1b
movq %rax, %r14
leaq 0xa7a1(%rip), %r12      # 0x11228
pushq $0xd
popq %rbx
movq (%r12), %r15
cmpl $0x15, (%r15)
jne 0x6ab6
movq 0x8(%r15), %rax
movq %rax, (%r12)
callq 0x6a1b
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5422
movq %rax, %r14
jmp 0x6a8a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_assign_expr
Node *parse_assign_expr() {
  Node *node = parse_lor_expr();
  Node *rhs;
  Token *op_token = token;
  if (consume_if(TK_ASSIGN)) {
    rhs = get_ptr_if_array(parse_assign_expr());
  } else if (consume_if(TK_ASSIGN_ADD)) {
    rhs = new_node_binary(ND_ADD, node, parse_assign_expr(), op_token);
  } else if (consume_if(TK_ASSIGN_SUB)) {
    rhs = new_node_binary(ND_SUB, node, parse_assign_expr(), op_token);
  } else if (consume_if(TK_ASSIGN_MUL)) {
    rhs = new_node_binary(ND_MUL, node, parse_assign_expr(), op_token);
  } else if (consume_if(TK_ASSIGN_DIV)) {
    rhs = new_node_binary(ND_DIV, node, parse_assign_expr(), op_token);
  } else
    return node;
  return new_node_expr(ND_ASSIGN, node, rhs, op_token);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x6a70
movq %rax, %rbx
leaq 0xa750(%rip), %rax      # 0x11228
movq (%rax), %r14
movl (%r14), %ecx
addl $-0xd, %ecx
cmpl $0x4, %ecx
ja 0x6b75
leaq 0x4717(%rip), %rdx      # 0xb208
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x6ac5
movq %rax, %rdi
callq 0x5470
jmp 0x6b5d
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x6ac5
pushq $0x7
jmp 0x6b4e
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x6ac5
pushq $0x5
jmp 0x6b4e
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x6ac5
pushq $0x6
jmp 0x6b4e
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x6ac5
pushq $0x4
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x5422
pushq $0x15
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x54df
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_for
Node *parse_for() {
  Token *op_token = token;
  Node *init = NULL;
  Node *cond;
  Node *post;
  Node *body;
  expect(TK_FOR);
  expect(TK_OP_PAREN);
  if (scope) scope->scope_head = true;
  LVar *save_scope = scope;

  if (!consume_if(TK_SEMI)) {
    if (is_type_specifier(token)) {
      init = parse_block_item();
    } else {
      init = parse_expr();
      expect(TK_SEMI);
    }
  }

  if (!peek(TK_SEMI)) {
    cond = parse_expr();
  } else {
    cond = new_node_num(1, token);
  }
  expect(TK_SEMI);
  if (peek(!TK_CL_PAREN))
    post = parse_expr();
  else
    post = NULL;
  expect(TK_CL_PAREN);

  body = parse_stmt();

  scope = save_scope;
  return new_node_for(init, cond, post, body, op_token);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xa691(%rip), %r12      # 0x11228
movq (%r12), %rbx
pushq $0x2c
popq %rdi
callq 0x5a46
pushq $0x1d
popq %rdi
callq 0x5a46
leaq 0xa69e(%rip), %r13      # 0x11250
movq (%r13), %rbp
testq %rbp, %rbp
je 0x6bbf
movb $0x1, 0x28(%rbp)
movq (%r12), %rdi
cmpl $0x1c, (%rdi)
jne 0x6bd5
movq 0x8(%rdi), %rax
movq %rax, (%r12)
xorl %r14d, %r14d
jmp 0x6bf8
callq 0x5ad3
testb %al, %al
je 0x6be8
callq 0x70a2
movq %rax, %r14
jmp 0x6bf8
callq 0x6ac5
movq %rax, %r14
pushq $0x1c
popq %rdi
callq 0x5a46
movq (%r12), %rsi
cmpl $0x1c, (%rsi)
jne 0x6c0b
pushq $0x1
popq %rdi
callq 0x5200
jmp 0x6c10
callq 0x6ac5
movq %rax, %r15
pushq $0x1c
popq %rdi
callq 0x5a46
movq (%r12), %rax
cmpl $0x0, (%rax)
je 0x6c29
xorl %r12d, %r12d
jmp 0x6c31
callq 0x6ac5
movq %rax, %r12
pushq $0x1e
popq %rdi
callq 0x5a46
callq 0x6c64
movq %rbp, (%r13)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5893
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_local_declaration
Node *parse_local_declaration() {
  MemberInfo *ty_ident = parse_decl(false);
  Token *ident = ty_ident->ident;
  Type *type = ty_ident->type;

  if (!ident) {
    if (!is_struct(type))
      error_at_token(token, "Expected an identifier.");
    else
      return NULL;
  }
  Node *node = NULL;
  if (is_func(type))
    error_at_token(ident, "Functions can be declared only in the top level.");
  Token *op_token = token;
  if (consume_if(TK_ASSIGN)) {
    node = parse_initializer(type);

    if (is_array_of_char(type) && node->kind == ND_STR) {
      type->array_size = node->offset;
    } else if (node->kind != ND_INIT) {
      node = get_ptr_if_array(node);
    }
    node =
        new_node_expr(ND_ASSIGN, new_node_lvar(new_lvar(ident, type), op_token),
                      node, op_token);
  } else {
    new_lvar(ident, type);
  }
  expect(TK_SEMI);
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x651c
movq 0x8(%rax), %r14
movq 0x10(%rax), %rbx
testq %r14, %r14
jne 0x6f60
movq %rbx, %rdi
callq 0x91ad
testb %al, %al
je 0x6f48
xorl %ebx, %ebx
jmp 0x7013
leaq 0xa2d9(%rip), %rax      # 0x11228
movq (%rax), %rdi
leaq 0x4688(%rip), %rsi      # 0xb5e1
xorl %eax, %eax
callq 0x48b3
movq %rbx, %rdi
callq 0x91a6
testb %al, %al
je 0x6f7d
leaq 0x4686(%rip), %rsi      # 0xb5f9
movq %r14, %rdi
xorl %eax, %eax
callq 0x48b3
leaq 0xa2a4(%rip), %rax      # 0x11228
movq (%rax), %r15
cmpl $0xd, (%r15)
jne 0x6fc2
movq 0x8(%r15), %rcx
movq %rcx, (%rax)
movq %rbx, %rdi
callq 0x7022
movq %rax, %r12
movq %rbx, %rdi
callq 0x91d5
movl (%r12), %ecx
cmpl $0x2, %ecx
sete %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x6fd1
movl 0x38(%r12), %eax
movl %eax, 0x10(%rbx)
jmp 0x6fe1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x575f
xorl %ebx, %ebx
jmp 0x700b
cmpl $0x3, %ecx
je 0x6fe1
movq %r12, %rdi
callq 0x5470
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x575f
movq %rax, %rdi
movq %r15, %rsi
callq 0x53c0
pushq $0x15
popq %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x54df
movq %rax, %rbx
pushq $0x1c
popq %rdi
callq 0x5a46
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_initializer
Node *parse_initializer(Type *ty) {
  if (peek(TK_OP_BRACE)) {
    if (is_array(ty)) {
      Node *init = parse_array_initializer(ty);
      if (ty->array_size == 0) ty->array_size = type(init)->array_size;
      return init;
    } else if (is_struct(ty)) {
      return parse_struct_initializer(ty);
    } else
      error_at_token(token, "Illegal initializer.");
  } else
    return parse_assign_expr();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xa1fb(%rip), %r14      # 0x11228
movq (%r14), %rax
cmpl $0x1f, (%rax)
jne 0x7062
movq %rdi, %rbx
callq 0x919f
movq %rbx, %rdi
testb %al, %al
je 0x706e
callq 0x7934
movq %rax, %r14
cmpl $0x0, 0x10(%rbx)
jne 0x7097
movq %r14, %rdi
callq 0x9610
movl 0x10(%rax), %eax
movl %eax, 0x10(%rbx)
jmp 0x7097
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6ac5
callq 0x91ad
testb %al, %al
je 0x7086
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x79ce
movq (%r14), %rdi
leaq 0x46bc(%rip), %rsi      # 0xb74c
xorl %eax, %eax
callq 0x48b3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_block_item
Node *parse_block_item() {
  if (consume_if(TK_TYPEDEF)) {
    MemberInfo *ty_ident = parse_decl(true);
    Token *ident = ty_ident->ident;
    Type *type = ty_ident->type;
    if (!ident) error_at_token(token, "Expected identifier.");
    new_typedef(ident, type);
    expect(TK_SEMI);
    return NULL;
  }
  if (is_type_specifier(token)) {
    // local var declaration
    return parse_local_declaration();
  }
  return parse_stmt();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xa17a(%rip), %r15      # 0x11228
movq (%r15), %rdi
cmpl $0x40, (%rdi)
jne 0x70fe
movq 0x8(%rdi), %rax
movq %rax, (%r15)
pushq $0x1
popq %rdi
callq 0x651c
movq 0x8(%rax), %rbx
movq 0x10(%rax), %r14
testq %rbx, %rbx
jne 0x70e3
movq (%r15), %rdi
leaq 0x428d(%rip), %rsi      # 0xb369
xorl %eax, %eax
callq 0x48b3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5d04
pushq $0x1c
popq %rdi
callq 0x5a46
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5ad3
testb %al, %al
je 0x7111
popq %rbx
popq %r14
popq %r15
jmp 0x6f19
popq %rbx
popq %r14
popq %r15
jmp 0x6c64
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_block
Node *parse_block() {
  expect(TK_OP_BRACE);
  Vector *vec = vec_new();
  if (scope) scope->scope_head = true;
  LVar *save_scope = scope;

  while (!peek(TK_CL_BRACE)) {
    Node *node = parse_block_item();
    if (node) vec_push(vec, node);
  }
  expect(TK_CL_BRACE);
  scope = save_scope;

  return new_node_block(vec);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1f
popq %rdi
callq 0x5a46
xorl %eax, %eax
callq 0x34c8
movq %rax, %rbx
leaq 0xa114(%rip), %r14      # 0x11250
movq (%r14), %r15
testq %r15, %r15
je 0x7149
movb $0x1, 0x28(%r15)
leaq 0xa0d8(%rip), %r12      # 0x11228
movq (%r12), %rax
cmpl $0x20, (%rax)
je 0x7170
callq 0x70a2
testq %rax, %rax
je 0x7150
movq %rbx, %rdi
movq %rax, %rsi
callq 0x34f6
jmp 0x7150
pushq $0x20
popq %rdi
callq 0x5a46
movq %r15, (%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x58fc
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_enum_specifier
Type *parse_enum_specifier() {
  Type *type = new_type_enum();
  if (peek(TK_IDENT)) type->tag_name = consume_ident();
  MemberInfo head;
  head.next = NULL;
  MemberInfo *cursor = &head;
  if (consume_if(TK_OP_BRACE)) {
    int i = 0;
    while (!peek(TK_CL_BRACE)) {
      Token *ident = consume_ident();
      // initializer
      if (consume_if(TK_ASSIGN)) {
        i = consume_number();
      }
      Type *new = new_type_enum_el(ident, i++);
      cursor->next = new_member_info(new->tag_name, new);
      cursor = cursor->next;
      new_tag(new->tag_name, new);
      if (!consume_if(TK_COMMA)) break;
    }
    expect(TK_CL_BRACE);
  }
  type->member = head.next;
  new_tag(type->tag_name, type);
  return type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x913f
movq %rax, %rbx
leaq 0x9e93(%rip), %r13      # 0x11228
movq (%r13), %rax
movl (%rax), %ecx
testl %ecx, %ecx
jne 0x73ae
callq 0x5a19
movq %rax, 0x30(%rbx)
movq (%r13), %rax
movl (%rax), %ecx
andq $0x0, (%rsp)
xorl %r14d, %r14d
cmpl $0x1f, %ecx
jne 0x7434
movq %rsp, %rbp
movq 0x8(%rax), %rax
movq %rax, (%r13)
cmpl $0x20, (%rax)
je 0x7428
callq 0x5a19
movq %rax, %r15
movq (%r13), %rax
cmpl $0xd, (%rax)
jne 0x73ec
movq 0x8(%rax), %rax
movq %rax, (%r13)
callq 0x59eb
movq %rax, %r14
movq %r15, %rdi
movl %r14d, %esi
callq 0x9153
movq %rax, %r15
movq 0x30(%rax), %rdi
movq %rax, %rsi
callq 0x5d40
movq %rax, %r12
movq %rax, (%rbp)
movq 0x30(%r15), %rdi
movq %r15, %rsi
callq 0x5c8a
movq (%r13), %rax
incl %r14d
cmpl $0x23, (%rax)
movq %r12, %rbp
je 0x73be
pushq $0x20
popq %rdi
callq 0x5a46
movq (%rsp), %r14
movq %r14, 0x20(%rbx)
movq 0x30(%rbx), %rdi
movq %rbx, %rsi
callq 0x5c8a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq