LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x68, %esi
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_O1/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_member
Node *new_node_member(Node *lhs, Token *ident) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_MEMBER;
  node->lhs = lhs;
  node->token = ident;
  Type *ty = type(lhs);
  if (!is_struct(ty))
    error_at_node(lhs, "The expression must have a struct or union type.");
  MemberInfo *mem = get_member_type(ty, ident);
  if (!mem) error_at_token(ident, "The member does not exists in the struct.");
  node->offset = mem->offset;
  node->type = mem->type;
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %rbx
movl $0x1b, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x50(%rax)
movq %r15, %rdi
callq 0xb354
movq %rax, %r12
movq %rax, %rdi
callq 0xaeb5
testb %al, %al
jne 0x5c7d
leaq 0x7642(%rip), %rsi      # 0xd2b5
movq %r15, %rdi
xorl %eax, %eax
callq 0x552e
movq %r12, %rdi
movq %r14, %rsi
callq 0x5cbf
movq %rax, %r15
testq %rax, %rax
jne 0x5ca1
leaq 0x764f(%rip), %rsi      # 0xd2e6
movq %r14, %rdi
xorl %eax, %eax
callq 0x52f9
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_O1/sisshiki1969[P]monocc/src/parse.c
// Function: get_member_type
MemberInfo *get_member_type(Type *type, Token *ident) {
  if (!is_struct(type)) error_at_token(ident, "Not a struct.");
  MemberInfo *member;
  if (!type->tag_name) {
    if (!type->member)
      error_at_token(ident, "No tag name and the type has no member.");
    member = type->member;
  } else {
    TagName *tag = find_tag(type->tag_name);
    if (!tag) error_at_token(ident, "Undefined tag name.");
    member = tag->type->member;
  }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xaeb5
testb %al, %al
jne 0x5ce6
leaq 0x769f(%rip), %rsi      # 0xd37b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x52f9
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x5d17
callq 0x64c9
movq %rax, %r14
testq %rax, %rax
jne 0x5d0d
leaq 0x76ae(%rip), %rsi      # 0xd3b1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x52f9
movq 0x10(%r14), %r15
addq $0x20, %r15
jmp 0x5d33
leaq 0x20(%r14), %r15
cmpq $0x0, 0x20(%r14)
jne 0x5d33
leaq 0x7660(%rip), %rsi      # 0xd389
movq %rbx, %rdi
xorl %eax, %eax
callq 0x52f9
movq (%r15), %r14
testq %r14, %r14
je 0x5d63
movl 0x28(%rbx), %ebp
movq 0x8(%r14), %rax
movslq 0x28(%rax), %rdx
cmpl %ebp, %edx
jne 0x5d5b
movq 0x20(%rax), %rdi
movq 0x20(%rbx), %rsi
callq 0x1120
testl %eax, %eax
je 0x5d66
movq (%r14), %r14
testq %r14, %r14
jne 0x5d3e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl %ebp, (%rax)
movq %rbx, 0x50(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x1c, (%rax)
movq %rbx, 0x50(%rax)
movq %r14, 0x58(%rax)
movq %r15, 0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x68, %esi
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_O1/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_if_then
Node *new_node_if_then(Node *cond_, Node *then_, Node *else_) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_IF;
  node->lhs = cond_;
  node->rhs = then_;
  node->xhs = else_;
  node->token = token;
  return node;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %r12
movl $0x20, (%rax)
xorl %eax, %eax
callq 0xad70
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5eb7
movq %rax, 0x30(%r12)
movq %r15, 0x8(%r12)
movq %r14, 0x10(%r12)
xorl %eax, %eax
callq 0x3f34
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_O1/sisshiki1969[P]monocc/src/parse.c
// Function: new_lvar
LVar *new_lvar(Token *token, Type *type) {
  LVar *lvar = calloc(1, sizeof(LVar));
  lvar->token = token;
  int offset;
  int size = sizeof_type(type);
  if (size == 0) {
    print_structs();
    error_at_token(token, "Inncomplete type is not allowed.");
  }
  if (locals) {
    offset = locals->offset + size;
  } else {
    offset = size;
    if (cur_fn->type->variadic) {
      offset += 128;
    } else {
      offset += 32;
    };
  }
  lvar->offset = offset;
  lvar->type = type;
  lvar->next = locals;
  locals = lvar;
  lvar->scope = scope;
  scope = lvar;

  return lvar;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x10d0
movq %rax, %rbx
movq %r15, 0x8(%rax)
movq %r14, %rdi
callq 0xafa3
movl %eax, %ebp
testl %eax, %eax
jne 0x5f00
xorl %eax, %eax
callq 0x4e7c
leaq 0x7464(%rip), %rsi      # 0xd35a
movq %r15, %rdi
xorl %eax, %eax
callq 0x52f9
leaq 0xd341(%rip), %rax      # 0x13248
movq (%rax), %rcx
testq %rcx, %rcx
je 0x5f14
addl 0x18(%rcx), %ebp
jmp 0x5f2d
movq 0xd355(%rip), %rdx      # 0x13270
movq 0x10(%rdx), %rdx
cmpb $0x1, 0x38(%rdx)
jne 0x5f2a
subl $-0x80, %ebp
jmp 0x5f2d
addl $0x20, %ebp
movl %ebp, 0x18(%rbx)
movq %r14, 0x10(%rbx)
movq %rcx, (%rbx)
movq %rbx, (%rax)
leaq 0xd30f(%rip), %rax      # 0x13250
movq (%rax), %rcx
movq %rcx, 0x20(%rbx)
movq %rbx, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x68, %esi
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_O1/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
movl $0x1, %edi
movl $0x68, %esi
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_O1/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_while
Node *new_node_while(Node *cond_, Node *do_) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_WHILE;
  node->lhs = cond_;
  node->rhs = do_;
  node->token = token;
  return node;
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %rbp
movl $0x1f, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
xorl %eax, %eax
callq 0x3f34
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x3f66
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_O1/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_block
Node *new_node_block(Vector *stmts) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = ND_BLOCK;
  node->nodes = stmts;
  node->token = token;
  return node;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x26, (%rax)
movq %rbx, 0x48(%rax)
leaq 0xd19d(%rip), %rcx      # 0x13228
movq (%rcx), %rcx
movq %rcx, 0x50(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x68, %esi
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_O1/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 0xd0c2(%rip), %rbx      # 0x13228
movq (%rbx), %rdi
cmpl $0x1, (%rdi)
je 0x617c
leaq 0x71aa(%rip), %rsi      # 0xd31f
xorl %eax, %eax
callq 0x52f9
movq (%rbx), %rcx
movslq 0x10(%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd094(%rip), %rbx      # 0x13228
movq (%rbx), %rdi
cmpl $0x0, (%rdi)
je 0x61aa
leaq 0x71a2(%rip), %rsi      # 0xd345
xorl %eax, %eax
callq 0x52f9
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %edi, %eax
leaq 0xd068(%rip), %rbx      # 0x13228
movq (%rbx), %rdi
cmpl %eax, (%rdi)
je 0x61d5
leaq 0x725c(%rip), %rsi      # 0xd42a
xorl %eax, %eax
callq 0x52f9
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x62b4
leaq 0xcfe3(%rip), %rax      # 0x13260
movq (%rax), %r15
testq %r15, %r15
je 0x62b4
movq %rdi, %r14
movl 0x28(%rdi), %ebp
xorl %ebx, %ebx
movq 0x10(%r15), %rax
movslq 0x28(%rax), %rdx
cmpl %ebp, %edx
jne 0x62aa
movq 0x20(%rax), %rdi
movq 0x20(%r14), %rsi
callq 0x1120
testl %eax, %eax
je 0x62c4
movq (%r15), %r15
testq %r15, %r15
jne 0x628d
jmp 0x62b6
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %rbx
jmp 0x62b6
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
leaq 0xcf7b(%rip), %rax      # 0x13250
movq (%rax), %rbx
testq %rbx, %rbx
je 0x6309
movq %rdi, %r14
movl 0x28(%rdi), %ebp
movq 0x8(%rbx), %rax
movslq 0x28(%rax), %rdx
cmpl %ebp, %edx
jne 0x6300
movq 0x20(%rax), %rdi
movq 0x20(%r14), %rsi
callq 0x1120
testl %eax, %eax
je 0x6309
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0x62e3
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xcf31(%rip), %rax      # 0x13250
movq (%rax), %r15
testq %r15, %r15
setne %bl
je 0x636b
cmpb $0x0, 0x28(%r15)
jne 0x6367
movq %rdi, %r14
movl 0x28(%rdi), %ebp
movq 0x8(%r15), %rax
movslq 0x28(%rax), %rdx
cmpl %ebp, %edx
jne 0x6354
movq 0x20(%rax), %rdi
movq 0x20(%r14), %rsi
callq 0x1120
testl %eax, %eax
je 0x637d
movq 0x20(%r15), %r15
testq %r15, %r15
setne %bl
je 0x636b
cmpb $0x0, 0x28(%r15)
je 0x6337
xorl %eax, %eax
jmp 0x636b
andb %al, %bl
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x636b
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/parse.c
// Function: new_gvar
Global *new_gvar(Token *ident, Type *type) {
  Global *global = calloc(1, sizeof(Global));
  global->next = globals;
  global->token = ident;
  global->type = type;
  globals = global;
  return global;
}

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0xce6b(%rip), %rax      # 0x13230
movq (%rax), %rbx
testq %rbx, %rbx
je 0x63f8
movq %rdi, %r14
movl 0x28(%rdi), %ebp
movq 0x8(%rbx), %rax
movslq 0x28(%rax), %rdx
cmpl %ebp, %edx
jne 0x63f0
movq 0x20(%rax), %rdi
movq 0x20(%r14), %rsi
callq 0x1120
testl %eax, %eax
je 0x63f8
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x63d3
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/parse.c
// Function: new_func
Function *new_func(Token *ident, Type *type, Node *body) {
  Function *func = calloc(1, sizeof(Function));
  func->next = functions;
  func->token = ident;
  func->type = type;
  func->body = body;
  functions = func;
  return func;
}

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0xce1e(%rip), %rax      # 0x13268
movq (%rax), %rbx
testq %rbx, %rbx
je 0x647d
movq %rdi, %r14
movl 0x28(%rdi), %ebp
movq 0x8(%rbx), %rax
movslq 0x28(%rax), %rdx
cmpl %ebp, %edx
jne 0x6475
movq 0x20(%rax), %rdi
movq 0x20(%r14), %rsi
callq 0x1120
testl %eax, %eax
je 0x647d
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x6458
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x64c6
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0x10d0
movq %r14, 0x30(%rbx)
leaq 0xcdaa(%rip), %rcx      # 0x13258
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x650e
leaq 0xcd7f(%rip), %rax      # 0x13258
movq (%rax), %rbx
testq %rbx, %rbx
je 0x6510
movq %rdi, %r14
movl 0x28(%rdi), %ebp
movq 0x8(%rbx), %rax
movslq 0x28(%rax), %rdx
cmpl %ebp, %edx
jne 0x6504
movq 0x20(%rax), %rdi
movq 0x20(%r14), %rsi
callq 0x1120
testl %eax, %eax
je 0x6510
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x64e7
jmp 0x6510
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6555
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0x10d0
leaq 0xcd23(%rip), %rcx      # 0x13260
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x8(%rax)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x20, %esi
callq 0x10d0
movq %rbx, 0x10(%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/parse.c
// Function: pointer_add
Node *pointer_add(Node *ptr, Node *offset, Token *token) {
  offset = new_node_binary(ND_MUL, offset,
                           new_node_num(sizeof_type(type(ptr)->ptr_to), token),
                           token);
  return new_node_binary(ND_ADD, ptr, offset, token);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xb354
movq 0x8(%rax), %rdi
callq 0xafa3
movslq %eax, %r13
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %r12
movl $0x1, (%rax)
movq %r13, 0x20(%rax)
movq %rbx, 0x50(%rax)
xorl %eax, %eax
callq 0xad70
movq %rax, 0x58(%r12)
movl $0x6, %edi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x5b07
movl $0x4, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5b07
// File: /workspace/github_c_makefile_star2_O1/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 0xc135(%rip), %rax      # 0x13228
movq (%rax), %r14
movl (%r14), %eax
leal -0x34(%rax), %ecx
cmpl $0x8, %ecx
jb 0x7127
addl $-0x3d, %eax
cmpl $0x2, %eax
jb 0x7127
movq %r14, %rdi
callq 0x626a
testq %rax, %rax
jne 0x7127
leaq 0x65e2(%rip), %rsi      # 0xd6ff
movq %r14, %rdi
xorl %eax, %eax
callq 0x52f9
movzbl %bl, %edi
callq 0x8844
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8260
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/parse.c
// Function: parse_cast_expr
Node *parse_cast_expr() {
  if (peek(TK_OP_PAREN) && is_type_specifier(token->next)) {
    expect(TK_OP_PAREN);
    Token *op_token = token;
    MemberInfo *info = parse_decl(false);
    expect(TK_CL_PAREN);
    Node *node = new_node_cast(parse_cast_expr(), info->type, op_token);
    return node;
  }
  return parse_unary_expr();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xc0de(%rip), %r14      # 0x13228
movq (%r14), %rax
cmpl $0x1d, (%rax)
jne 0x71dd
movq 0x8(%rax), %rdi
movl (%rdi), %eax
leal -0x34(%rax), %ecx
cmpl $0x8, %ecx
jb 0x7176
addl $-0x3d, %eax
cmpl $0x2, %eax
jb 0x7176
callq 0x626a
testq %rax, %rax
je 0x71dd
movq (%r14), %rax
movq 0x8(%rax), %r15
movq %r15, (%r14)
xorl %edi, %edi
callq 0x70e6
movq %rax, %rbx
movq (%r14), %rdi
cmpl $0x1e, (%rdi)
je 0x71a0
leaq 0x6291(%rip), %rsi      # 0xd42a
xorl %eax, %eax
callq 0x52f9
movq (%r14), %rax
movq 0x8(%rax), %rax
movq %rax, (%r14)
callq 0x713e
movq %rax, %r14
movq 0x10(%rbx), %rbx
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x1c, (%rax)
movq %r15, 0x50(%rax)
movq %rbx, 0x58(%rax)
movq %r14, 0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
popq %rbx
popq %r14
popq %r15
jmp 0x6eac
// File: /workspace/github_c_makefile_star2_O1/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 0x713e
movq %rax, %rbx
leaq 0xc027(%rip), %r13      # 0x13228
movq (%r13), %r15
movl $0x6, %ebp
cmpl $0x5, (%r15)
movq %r15, %rax
je 0x7221
movq (%r13), %rax
movl $0x7, %ebp
cmpl $0x6, (%rax)
jne 0x7258
movq 0x8(%rax), %rax
movq %rax, (%r13)
callq 0x713e
movq %rax, %r12
movq %rbx, %rdi
callq 0xb328
movq %r12, %rdi
callq 0xb328
movl %ebp, %edi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x5b07
movq %rax, %rbx
movb $0x1, %al
jmp 0x725d
xorl %eax, %eax
movq %rbx, %r14
testb %al, %al
jne 0x7201
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_O1/sisshiki1969[P]monocc/src/parse.c
// Function: parse_add_expr
Node *parse_add_expr() {
  Node *lhs = parse_mul_expr();
  Node *rhs;
  while (true) {
    Token *op_token = token;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x71e7
movq %rax, %r14
leaq 0xbf9d(%rip), %r13      # 0x13228
movq (%r13), %r15
cmpl $0x3, (%r15)
jne 0x72d5
movq 0x8(%r15), %rax
movq %rax, (%r13)
callq 0x71e7
movq %rax, %r12
movq %r14, %rdi
callq 0xb354
movq %rax, %rdi
callq 0xaea0
testb %al, %al
je 0x731e
movq %r12, %rdi
callq 0xb354
movq %rax, %rdi
callq 0xaef0
testb %al, %al
je 0x731e
movq %r14, %rdi
movq %r12, %rsi
jmp 0x734c
movq (%r13), %rax
cmpl $0x4, (%rax)
jne 0x735d
movq 0x8(%rax), %rax
movq %rax, (%r13)
callq 0x71e7
movq %rax, %r12
movq %r14, %rdi
callq 0xb354
movq %rax, %rdi
callq 0xaea0
testb %al, %al
je 0x7364
movq %r12, %rdi
callq 0xb354
movq %rax, %rdi
callq 0xaef0
testb %al, %al
je 0x7364
movq %r14, %rdi
movq %r12, %rsi
jmp 0x7392
movq %r14, %rdi
callq 0xb354
movq %rax, %rdi
callq 0xaef0
testb %al, %al
je 0x7356
movq %r12, %rdi
callq 0xb354
movq %rax, %rdi
callq 0xaea0
testb %al, %al
je 0x7356
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6852
jmp 0x73af
movl $0x4, %edi
jmp 0x73a1
xorl %eax, %eax
movq %r14, %rbx
jmp 0x73b4
movq %r14, %rdi
callq 0xb354
movq %rax, %rdi
callq 0xaea0
testb %al, %al
je 0x739c
movq %r12, %rdi
callq 0xb354
movq %rax, %rdi
callq 0xaef0
testb %al, %al
je 0x739c
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x68d0
jmp 0x73af
movl $0x5, %edi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x5b07
movq %rax, %r14
movb $0x1, %al
testb %al, %al
jne 0x728b
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7273
movq %rax, %rbx
leaq 0xbe45(%rip), %r13      # 0x13228
movq (%r13), %r15
movl $0x12, %ebp
cmpl $0x1a, (%r15)
movq %r15, %rax
je 0x7403
movq (%r13), %rax
movl $0x13, %ebp
cmpl $0x1b, (%rax)
jne 0x743a
movq 0x8(%rax), %rax
movq %rax, (%r13)
callq 0x7273
movq %rax, %r12
movq %rbx, %rdi
callq 0xb328
movq %r12, %rdi
callq 0xb328
movl %ebp, %edi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x5b07
movq %rax, %rbx
movb $0x1, %al
jmp 0x743f
xorl %eax, %eax
movq %rbx, %r14
testb %al, %al
jne 0x73e3
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_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x73c9
movq %rax, %r14
leaq 0xbdbc(%rip), %r12      # 0x13228
movq (%r12), %r15
cmpl $0xa, (%r15)
jne 0x748a
movq 0x8(%r15), %rax
movq %rax, (%r12)
callq 0x73c9
movl $0xa, %edi
jmp 0x74a5
movq (%r12), %rax
cmpl $0x9, (%rax)
jne 0x74be
movq 0x8(%rax), %rax
movq %rax, (%r12)
callq 0x73c9
movl $0xb, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5b07
movq %rax, %r14
movb $0x1, %al
testb %al, %al
jne 0x746c
jmp 0x7505
movq (%r12), %rax
cmpl $0xc, (%rax)
jne 0x74db
movq 0x8(%rax), %rax
movq %rax, (%r12)
callq 0x73c9
movl $0xa, %edi
jmp 0x74f6
movq (%r12), %rax
cmpl $0xb, (%rax)
jne 0x74fe
movq 0x8(%rax), %rax
movq %rax, (%r12)
callq 0x73c9
movl $0xb, %edi
movq %rax, %rsi
movq %r14, %rdx
jmp 0x74ab
xorl %eax, %eax
movq %r14, %rbx
jmp 0x74b8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
callq 0x7455
movq %rax, %rbx
leaq 0xbcfd(%rip), %r12      # 0x13228
movq (%r12), %r15
movl $0x8, %ebp
cmpl $0x7, (%r15)
movq %r15, %rax
je 0x754b
movq (%r12), %rax
movl $0x9, %ebp
cmpl $0x8, (%rax)
jne 0x756f
movq 0x8(%rax), %rax
movq %rax, (%r12)
callq 0x7455
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5b07
movq %rax, %rbx
movb $0x1, %al
jmp 0x7574
xorl %eax, %eax
movq %rbx, %r14
testb %al, %al
jne 0x752b
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x7514
movq %rax, %rbx
leaq 0xbc8a(%rip), %r13      # 0x13228
movq (%r13), %r15
movl (%r15), %ebp
cmpl $0x16, %ebp
jne 0x75e2
movq 0x8(%r15), %rax
movq %rax, (%r13)
callq 0x7514
movq %rax, %r12
movq %rbx, %rdi
callq 0xb328
movq %r12, %rdi
callq 0xb328
movl $0xf, %edi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x5b07
movq %rax, %rbx
jmp 0x75e5
movq %rbx, %r14
cmpl $0x16, %ebp
je 0x759e
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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x7584
movq %rax, %rbx
leaq 0xbc12(%rip), %r13      # 0x13228
movq (%r13), %r15
movl (%r15), %ebp
cmpl $0x18, %ebp
jne 0x765a
movq 0x8(%r15), %rax
movq %rax, (%r13)
callq 0x7584
movq %rax, %r12
movq %rbx, %rdi
callq 0xb328
movq %r12, %rdi
callq 0xb328
movl $0x11, %edi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x5b07
movq %rax, %rbx
jmp 0x765d
movq %rbx, %r14
cmpl $0x18, %ebp
je 0x7616
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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x75fc
movq %rax, %rbx
leaq 0xbb9a(%rip), %r13      # 0x13228
movq (%r13), %r15
movl (%r15), %ebp
cmpl $0x17, %ebp
jne 0x76d2
movq 0x8(%r15), %rax
movq %rax, (%r13)
callq 0x75fc
movq %rax, %r12
movq %rbx, %rdi
callq 0xb328
movq %r12, %rdi
callq 0xb328
movl $0x10, %edi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x5b07
movq %rax, %rbx
jmp 0x76d5
movq %rbx, %r14
cmpl $0x17, %ebp
je 0x768e
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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x7674
movq %rax, %rbx
leaq 0xbb25(%rip), %r12      # 0x13228
movq (%r12), %r15
movl (%r15), %ebp
cmpl $0x14, %ebp
jne 0x7734
movq 0x8(%r15), %rax
movq %rax, (%r12)
callq 0x7674
movl $0xc, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5b07
movq %rax, %rbx
jmp 0x7737
movq %rbx, %r14
cmpl $0x14, %ebp
je 0x7703
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x76ec
movq %rax, %rbx
leaq 0xbac9(%rip), %r12      # 0x13228
movq (%r12), %r15
movl (%r15), %ebp
cmpl $0x15, %ebp
jne 0x7790
movq 0x8(%r15), %rax
movq %rax, (%r12)
callq 0x76ec
movl $0xd, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5b07
movq %rax, %rbx
jmp 0x7793
movq %rbx, %r14
cmpl $0x15, %ebp
je 0x775f
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
callq 0x7748
movq %rax, %rbx
leaq 0xba70(%rip), %rax      # 0x13228
movq (%rax), %r14
cmpl $0xd, (%r14)
jne 0x77d7
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x77a4
movq %rax, %rdi
callq 0x5b59
jmp 0x784f
movq (%rax), %rcx
cmpl $0xe, (%rcx)
jne 0x77f2
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
callq 0x77a4
movl $0x4, %edi
jmp 0x7841
movq (%rax), %rcx
cmpl $0xf, (%rcx)
jne 0x780d
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
callq 0x77a4
movl $0x5, %edi
jmp 0x7841
movq (%rax), %rcx
cmpl $0x10, (%rcx)
jne 0x7828
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
callq 0x77a4
movl $0x6, %edi
jmp 0x7841
movq (%rax), %rcx
cmpl $0x11, (%rcx)
jne 0x7876
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
callq 0x77a4
movl $0x7, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x5b07
movq %rax, %r15
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x15, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x50(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb992(%rip), %r13      # 0x13228
movq (%r13), %rbx
cmpl $0x2c, (%rbx)
je 0x78b0
leaq 0x5b84(%rip), %rsi      # 0xd42a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x52f9
movq (%r13), %rax
movq 0x8(%rax), %rdi
movq %rdi, (%r13)
cmpl $0x1d, (%rdi)
je 0x78cf
leaq 0x5b62(%rip), %rsi      # 0xd42a
xorl %eax, %eax
callq 0x52f9
movq (%r13), %rax
movq 0x8(%rax), %rax
movq %rax, (%r13)
leaq 0xb96e(%rip), %r14      # 0x13250
movq (%r14), %rbp
testq %rbp, %rbp
je 0x78ee
movb $0x1, 0x28(%rbp)
cmpl $0x1c, (%rax)
jne 0x7905
movq 0x8(%rax), %rax
movq %rax, (%r13)
movq $0x0, (%rsp)
jmp 0x7932
movq (%r13), %rdi
movl (%rdi), %eax
leal -0x34(%rax), %ecx
cmpl $0x8, %ecx
jb 0x7929
addl $-0x3d, %eax
cmpl $0x2, %eax
jb 0x7929
callq 0x626a
testq %rax, %rax
je 0x79f9
callq 0x80f7
movq %rax, (%rsp)
movq (%r13), %r12
cmpl $0x1c, (%r12)
jne 0x796e
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %r15
movl $0x1, (%rax)
movq $0x1, 0x20(%rax)
movq %r12, 0x50(%rax)
xorl %eax, %eax
callq 0xad70
movq %rax, 0x58(%r15)
jmp 0x7976
callq 0x77a4
movq %rax, %r15
movq (%r13), %rdi
cmpl $0x1c, (%rdi)
je 0x798d
leaq 0x5aa4(%rip), %rsi      # 0xd42a
xorl %eax, %eax
callq 0x52f9
movq (%r13), %rax
movq 0x8(%rax), %rax
movq %rax, (%r13)
cmpl $0x0, (%rax)
je 0x79a3
xorl %r12d, %r12d
jmp 0x79ab
callq 0x77a4
movq %rax, %r12
movq (%r13), %rdi
cmpl $0x1e, (%rdi)
je 0x79c2
leaq 0x5a6f(%rip), %rsi      # 0xd42a
xorl %eax, %eax
callq 0x52f9
movq (%r13), %rax
movq 0x8(%rax), %rax
movq %rax, (%r13)
callq 0x7a2a
movq %rbp, (%r14)
movq (%rsp), %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 0x5ffa
callq 0x77a4
movq %rax, (%rsp)
movq (%r13), %rdi
cmpl $0x1c, (%rdi)
je 0x7a19
leaq 0x5a18(%rip), %rsi      # 0xd42a
xorl %eax, %eax
callq 0x52f9
movq (%r13), %rax
movq 0x8(%rax), %rax
movq %rax, (%r13)
jmp 0x7932
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
xorl %edi, %edi
callq 0x70e6
movq 0x8(%rax), %r14
movq 0x10(%rax), %rbx
testq %r14, %r14
jne 0x7f70
movq %rbx, %rdi
callq 0xaeb5
testb %al, %al
je 0x7f58
xorl %ebx, %ebx
jmp 0x806a
leaq 0xb2c9(%rip), %rax      # 0x13228
movq (%rax), %rdi
leaq 0x5654(%rip), %rsi      # 0xd5bd
xorl %eax, %eax
callq 0x52f9
movq %rbx, %rdi
callq 0xaeae
testb %al, %al
je 0x7f8d
leaq 0x5652(%rip), %rsi      # 0xd5d5
movq %r14, %rdi
xorl %eax, %eax
callq 0x52f9
leaq 0xb294(%rip), %r12      # 0x13228
movq (%r12), %r13
cmpl $0xd, (%r13)
jne 0x7fcd
movq 0x8(%r13), %rax
movq %rax, (%r12)
movq %rbx, %rdi
callq 0x8077
movq %rax, %r15
movq %rbx, %rdi
callq 0xaedd
testb %al, %al
je 0x7fdc
cmpl $0x2, (%r15)
jne 0x7fdc
movl 0x38(%r15), %eax
movl %eax, 0x10(%rbx)
jmp 0x7fed
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5eb7
xorl %ebx, %ebx
jmp 0x8047
cmpl $0x3, (%r15)
je 0x7fed
movq %r15, %rdi
callq 0x5b59
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5eb7
movq %rax, %rbx
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %r14
movl $0x18, (%rax)
movq %rbx, 0x30(%rax)
movq %r13, 0x50(%rax)
movq 0x10(%rbx), %rax
movq %rax, 0x58(%r14)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %rbx
movl $0x15, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r13, 0x50(%rax)
movq (%r12), %rdi
cmpl $0x1c, (%rdi)
je 0x805e
leaq 0x53d3(%rip), %rsi      # 0xd42a
xorl %eax, %eax
callq 0x52f9
movq (%r12), %rax
movq 0x8(%rax), %rax
movq %rax, (%r12)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb1a6(%rip), %r14      # 0x13228
movq (%r14), %rax
cmpl $0x1f, (%rax)
jne 0x80b7
movq %rdi, %rbx
callq 0xaea7
movq %rbx, %rdi
testb %al, %al
je 0x80c3
callq 0x8c60
movq %rax, %r14
cmpl $0x0, 0x10(%rbx)
jne 0x80ec
movq %r14, %rdi
callq 0xb354
movl 0x10(%rax), %eax
movl %eax, 0x10(%rbx)
jmp 0x80ec
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x77a4
callq 0xaeb5
testb %al, %al
je 0x80db
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8d3e
movq (%r14), %rdi
leaq 0x5643(%rip), %rsi      # 0xd728
xorl %eax, %eax
callq 0x52f9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb125(%rip), %rbx      # 0x13228
movq (%rbx), %rax
cmpl $0x40, (%rax)
jne 0x8152
movq 0x8(%rax), %rax
movq %rax, (%rbx)
movl $0x1, %edi
callq 0x70e6
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x817b
movq 0x10(%rax), %r15
movl $0x1, %edi
movl $0x18, %esi
callq 0x10d0
leaq 0xb121(%rip), %rcx      # 0x13260
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x8(%rax)
movq %rax, (%rcx)
jmp 0x818c
movq (%rbx), %rdi
movl (%rdi), %eax
leal -0x34(%rax), %ecx
cmpl $0x8, %ecx
jb 0x8171
addl $-0x3d, %eax
cmpl $0x2, %eax
jb 0x8171
callq 0x626a
testq %rax, %rax
je 0x81b4
popq %rbx
popq %r14
popq %r15
jmp 0x7f28
movq (%rbx), %rdi
leaq 0x51c0(%rip), %rsi      # 0xd345
xorl %eax, %eax
callq 0x52f9
movq (%rbx), %rdi
cmpl $0x1c, (%rdi)
je 0x81a2
leaq 0x528f(%rip), %rsi      # 0xd42a
xorl %eax, %eax
callq 0x52f9
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
popq %rbx
popq %r14
popq %r15
jmp 0x7a2a
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
leaq 0xb05a(%rip), %r14      # 0x13228
movq (%r14), %rdi
cmpl $0x1f, (%rdi)
je 0x81e4
leaq 0x524d(%rip), %rsi      # 0xd42a
xorl %eax, %eax
callq 0x52f9
movq (%r14), %rax
movq 0x8(%rax), %rax
movq %rax, (%r14)
xorl %eax, %eax
callq 0x3f34
movq %rax, %rbx
leaq 0xb051(%rip), %r15      # 0x13250
movq (%r15), %r12
testq %r12, %r12
je 0x8224
movb $0x1, 0x28(%r12)
jmp 0x8224
callq 0x80f7
testq %rax, %rax
je 0x8224
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3f66
movq (%r14), %rax
cmpl $0x20, (%rax)
jne 0x820f
movq (%r14), %rax
movq 0x8(%rax), %r13
movq %r13, (%r14)
movq %r12, (%r15)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x26, (%rax)
movq %rbx, 0x48(%rax)
movq %r13, 0x50(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq