LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x22, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1e, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0xdc3c(%rip), %rax      # 0x15218
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: new_node_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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x1f, (%rax)
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movb $0x0, %al
callq 0x3fb0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4020
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x26, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
leaq 0xdb3c(%rip), %rax      # 0x15218
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: add_stmt_to_block
void add_stmt_to_block(Node *block, Node *node) {
  if (block->kind == ND_BLOCK) {
    if (node) vec_push(block->nodes, node);
    return;
  } else
    error_at_node(block, "Must be block.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x26, (%rax)
jne 0x7733
cmpq $0x0, -0x10(%rbp)
je 0x7731
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4020
jmp 0x7745
movq -0x8(%rbp), %rdi
leaq 0x8c72(%rip), %rsi      # 0x103b0
movb $0x0, %al
callq 0x6040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x27, (%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: consume_if
bool consume_if(TokenKind kind) {
  if (token->kind == kind) {
    token = token->next;
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
leaq 0xd9aa(%rip), %rax      # 0x15218
movq (%rax), %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x7896
leaq 0xd999(%rip), %rax      # 0x15218
movq (%rax), %rax
movq 0x8(%rax), %rcx
leaq 0xd98b(%rip), %rax      # 0x15218
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x789a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xd959(%rip), %rax      # 0x15218
movq (%rax), %rax
cmpl $0x1, (%rax)
je 0x78df
leaq 0xd94a(%rip), %rax      # 0x15218
movq (%rax), %rdi
leaq 0x8ae7(%rip), %rsi      # 0x103bf
movb $0x0, %al
callq 0x5d20
leaq 0xd932(%rip), %rax      # 0x15218
movq (%rax), %rax
movq 0x10(%rax), %rax
movl %eax, -0x4(%rbp)
leaq 0xd921(%rip), %rax      # 0x15218
movq (%rax), %rax
movq 0x8(%rax), %rcx
leaq 0xd913(%rip), %rax      # 0x15218
movq %rcx, (%rax)
movslq -0x4(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xd8e9(%rip), %rax      # 0x15218
movq (%rax), %rax
cmpl $0x0, (%rax)
je 0x794f
leaq 0xd8da(%rip), %rax      # 0x15218
movq (%rax), %rdi
leaq 0x8a9d(%rip), %rsi      # 0x103e5
movb $0x0, %al
callq 0x5d20
leaq 0xd8c2(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0xd8b4(%rip), %rax      # 0x15218
movq (%rax), %rax
movq 0x8(%rax), %rcx
leaq 0xd8a6(%rip), %rax      # 0x15218
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0xd886(%rip), %rax      # 0x15218
movq (%rax), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
je 0x79b4
leaq 0xd875(%rip), %rax      # 0x15218
movq (%rax), %rdi
leaq 0x8b1d(%rip), %rsi      # 0x104ca
movb $0x0, %al
callq 0x5d20
leaq 0xd85d(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0xd84f(%rip), %rax      # 0x15218
movq (%rax), %rax
movq 0x8(%rax), %rcx
leaq 0xd841(%rip), %rax      # 0x15218
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: is_type_specifier
bool is_type_specifier(Token *token) {
  switch (token->kind) {
    case TK_UNSIGNED:
    case TK_SIGNED:
    case TK_CHAR:
    case TK_INT:
    case TK_SHORT:
    case TK_LONG:
    case TK_BOOL:
    case TK_VOID:
    case TK_STRUCT:
    case TK_ENUM:
      return true;
  }
  if (find_typedef(token)) return true;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
addl $-0x34, %eax
subl $0x8, %eax
jb 0x7aec
jmp 0x7adf
movl -0x14(%rbp), %eax
addl $-0x3d, %eax
subl $0x1, %eax
ja 0x7af2
jmp 0x7aec
movb $0x1, -0x1(%rbp)
jmp 0x7b0b
movq -0x10(%rbp), %rdi
callq 0x7b20
cmpq $0x0, %rax
je 0x7b07
movb $0x1, -0x1(%rbp)
jmp 0x7b0b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7b3d
movq $0x0, -0x8(%rbp)
jmp 0x7b8c
leaq 0xd70c(%rip), %rax      # 0x15250
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7b84
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x79f0
testb $0x1, %al
jne 0x7b69
jmp 0x7b77
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7b8c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7b4b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xd68d(%rip), %rax      # 0x15240
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7bf2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x79f0
testb $0x1, %al
jne 0x7bd8
jmp 0x7be2
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7bfa
jmp 0x7be4
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7bba
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xd61d(%rip), %rax      # 0x15240
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7c6e
movq -0x18(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0x7c41
movb $0x0, -0x1(%rbp)
jmp 0x7c72
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x79f0
testb $0x1, %al
jne 0x7c58
jmp 0x7c5e
movb $0x1, -0x1(%rbp)
jmp 0x7c72
jmp 0x7c60
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7c2a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
leaq 0xd576(%rip), %rax      # 0x15220
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
leaq 0xd549(%rip), %rax      # 0x15220
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xd51d(%rip), %rax      # 0x15220
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7d41
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x79f0
testb $0x1, %al
jne 0x7d28
jmp 0x7d32
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7d49
jmp 0x7d34
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7d0a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x10d0
movq %rax, -0x20(%rbp)
leaq 0xd4ca(%rip), %rax      # 0x15258
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
leaq 0xd491(%rip), %rax      # 0x15258
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xd465(%rip), %rax      # 0x15258
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7e31
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x79f0
testb $0x1, %al
jne 0x7e18
jmp 0x7e22
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7e39
jmp 0x7e24
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7dfa
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7e71
movq $0x0, -0x8(%rbp)
jmp 0x7ec7
movl $0x1, %edi
movl $0x18, %esi
callq 0x10d0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
leaq 0xd3b1(%rip), %rax      # 0x15248
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
leaq 0xd384(%rip), %rax      # 0x15248
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7efd
movq $0x0, -0x8(%rbp)
jmp 0x7f4a
leaq 0xd344(%rip), %rax      # 0x15248
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7f42
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x79f0
testb $0x1, %al
jne 0x7f29
jmp 0x7f33
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7f4a
jmp 0x7f35
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7f0b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7f81
movq $0x0, -0x8(%rbp)
jmp 0x7fcb
movl $0x1, %edi
movl $0x18, %esi
callq 0x10d0
movq %rax, -0x20(%rbp)
leaq 0xd2b5(%rip), %rax      # 0x15250
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
leaq 0xd288(%rip), %rax      # 0x15250
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: new_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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdda0
movq 0x8(%rax), %rdi
callq 0xd640
movslq %eax, %rdi
movq -0x18(%rbp), %rsi
callq 0x69f0
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movl $0x6, %edi
callq 0x6e30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x4, %edi
callq 0x6e30
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq 0xc6c1(%rip), %rax      # 0x15218
movq (%rax), %rdi
callq 0x7ac0
testb $0x1, %al
jne 0x8b7b
leaq 0xc6ae(%rip), %rax      # 0x15218
movq (%rax), %rdi
leaq 0x7c2b(%rip), %rsi      # 0x1079f
movb $0x0, %al
callq 0x5d20
movb -0x1(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0xa320
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9d00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1d, %edi
callq 0x77d0
testb $0x1, %al
jne 0x8bb8
jmp 0x8c25
leaq 0xc659(%rip), %rax      # 0x15218
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x7ac0
testb $0x1, %al
jne 0x8bd1
jmp 0x8c25
movl $0x1d, %edi
callq 0x7980
leaq 0xc636(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x10(%rbp)
xorl %edi, %edi
callq 0x8b40
movq %rax, -0x18(%rbp)
movl $0x1e, %edi
callq 0x7980
callq 0x8ba0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x71f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8c2e
callq 0x88f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x8ba0
movq %rax, -0x8(%rbp)
leaq 0xc5c0(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x5, %edi
callq 0x7860
testb $0x1, %al
jne 0x8c6f
jmp 0x8c94
callq 0x8ba0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x6, %edi
callq 0x6f20
movq %rax, -0x8(%rbp)
jmp 0x8c51
movl $0x6, %edi
callq 0x7860
testb $0x1, %al
jne 0x8ca4
jmp 0x8cc9
callq 0x8ba0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x7, %edi
callq 0x6f20
movq %rax, -0x8(%rbp)
jmp 0x8c51
jmp 0x8ccb
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x8c40
movq %rax, -0x8(%rbp)
leaq 0xc520(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x3, %edi
callq 0x7860
testb $0x1, %al
jne 0x8d12
jmp 0x8dc6
callq 0x8c40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdda0
movq %rax, %rdi
callq 0xd350
testb $0x1, %al
jne 0x8d32
jmp 0x8d60
movq -0x10(%rbp), %rdi
callq 0xdda0
movq %rax, %rdi
callq 0xd490
testb $0x1, %al
jne 0x8d49
jmp 0x8d60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x8300
movq %rax, -0x8(%rbp)
jmp 0x8dc1
movq -0x8(%rbp), %rdi
callq 0xdda0
movq %rax, %rdi
callq 0xd490
testb $0x1, %al
jne 0x8d77
jmp 0x8da5
movq -0x10(%rbp), %rdi
callq 0xdda0
movq %rax, %rdi
callq 0xd350
testb $0x1, %al
jne 0x8d8e
jmp 0x8da5
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x8300
movq %rax, -0x8(%rbp)
jmp 0x8dbf
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x4, %edi
callq 0x6e30
movq %rax, -0x8(%rbp)
jmp 0x8dc1
jmp 0x8cf1
movl $0x4, %edi
callq 0x7860
testb $0x1, %al
jne 0x8dd9
jmp 0x8e8d
callq 0x8c40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdda0
movq %rax, %rdi
callq 0xd350
testb $0x1, %al
jne 0x8df9
jmp 0x8e27
movq -0x10(%rbp), %rdi
callq 0xdda0
movq %rax, %rdi
callq 0xd490
testb $0x1, %al
jne 0x8e10
jmp 0x8e27
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x8370
movq %rax, -0x8(%rbp)
jmp 0x8e88
movq -0x8(%rbp), %rdi
callq 0xdda0
movq %rax, %rdi
callq 0xd350
testb $0x1, %al
jne 0x8e3e
jmp 0x8e6c
movq -0x10(%rbp), %rdi
callq 0xdda0
movq %rax, %rdi
callq 0xd490
testb $0x1, %al
jne 0x8e55
jmp 0x8e6c
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x8370
movq %rax, -0x8(%rbp)
jmp 0x8e86
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x5, %edi
callq 0x6e30
movq %rax, -0x8(%rbp)
jmp 0x8e88
jmp 0x8cf1
jmp 0x8e8f
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x8ce0
movq %rax, -0x8(%rbp)
leaq 0xc360(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x1a, %edi
callq 0x7860
testb $0x1, %al
jne 0x8ecf
jmp 0x8ef4
callq 0x8ce0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x12, %edi
callq 0x6f20
movq %rax, -0x8(%rbp)
jmp 0x8eb1
movl $0x1b, %edi
callq 0x7860
testb $0x1, %al
jne 0x8f04
jmp 0x8f29
callq 0x8ce0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x13, %edi
callq 0x6f20
movq %rax, -0x8(%rbp)
jmp 0x8eb1
jmp 0x8f2b
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x8ea0
movq %rax, -0x8(%rbp)
leaq 0xc2c0(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0xa, %edi
callq 0x7860
testb $0x1, %al
jne 0x8f6f
jmp 0x8f97
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x8ea0
movq -0x18(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movl $0xa, %edi
callq 0x6e30
movq %rax, -0x8(%rbp)
jmp 0x8f51
movl $0x9, %edi
callq 0x7860
testb $0x1, %al
jne 0x8fa7
jmp 0x8fcf
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x8ea0
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movl $0xb, %edi
callq 0x6e30
movq %rax, -0x8(%rbp)
jmp 0x8f51
movl $0xc, %edi
callq 0x7860
testb $0x1, %al
jne 0x8fdf
jmp 0x9002
callq 0x8ea0
movq %rax, %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0xa, %edi
callq 0x6e30
movq %rax, -0x8(%rbp)
jmp 0x8f51
movl $0xb, %edi
callq 0x7860
testb $0x1, %al
jne 0x9012
jmp 0x9035
callq 0x8ea0
movq %rax, %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0xb, %edi
callq 0x6e30
movq %rax, -0x8(%rbp)
jmp 0x8f51
jmp 0x9037
jmp 0x9039
jmp 0x903b
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x8f40
movq %rax, -0x8(%rbp)
leaq 0xc1b0(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x7, %edi
callq 0x7860
testb $0x1, %al
jne 0x907f
jmp 0x90a7
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x8f40
movq -0x18(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movl $0x8, %edi
callq 0x6e30
movq %rax, -0x8(%rbp)
jmp 0x9061
movl $0x8, %edi
callq 0x7860
testb $0x1, %al
jne 0x90b7
jmp 0x90df
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x8f40
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movl $0x9, %edi
callq 0x6e30
movq %rax, -0x8(%rbp)
jmp 0x9061
jmp 0x90e1
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x9050
movq %rax, -0x8(%rbp)
leaq 0xc110(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x16, %edi
callq 0x7860
testb $0x1, %al
jne 0x911f
jmp 0x9147
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x9050
movq -0x18(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movl $0xf, %edi
callq 0x6f20
movq %rax, -0x8(%rbp)
jmp 0x9101
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x90f0
movq %rax, -0x8(%rbp)
leaq 0xc0a0(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x18, %edi
callq 0x7860
testb $0x1, %al
jne 0x918f
jmp 0x91b7
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x90f0
movq -0x18(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movl $0x11, %edi
callq 0x6f20
movq %rax, -0x8(%rbp)
jmp 0x9171
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x9160
movq %rax, -0x8(%rbp)
leaq 0xc030(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x17, %edi
callq 0x7860
testb $0x1, %al
jne 0x91ff
jmp 0x9227
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x9160
movq -0x18(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movl $0x10, %edi
callq 0x6f20
movq %rax, -0x8(%rbp)
jmp 0x91e1
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x91d0
movq %rax, -0x8(%rbp)
leaq 0xbfc0(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x14, %edi
callq 0x7860
testb $0x1, %al
jne 0x926f
jmp 0x9297
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x91d0
movq -0x18(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movl $0xc, %edi
callq 0x6e30
movq %rax, -0x8(%rbp)
jmp 0x9251
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x9240
movq %rax, -0x8(%rbp)
leaq 0xbf50(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x15, %edi
callq 0x7860
testb $0x1, %al
jne 0x92df
jmp 0x9307
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x9240
movq -0x18(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movl $0xd, %edi
callq 0x6e30
movq %rax, -0x8(%rbp)
jmp 0x92c1
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/parse.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
callq 0x92b0
movq %rax, -0x10(%rbp)
leaq 0xbee0(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0xd, %edi
callq 0x7860
testb $0x1, %al
jne 0x934f
jmp 0x9365
callq 0x9320
movq %rax, %rdi
callq 0x6eb0
movq %rax, -0x18(%rbp)
jmp 0x945a
movl $0xe, %edi
callq 0x7860
testb $0x1, %al
jne 0x9375
jmp 0x93a0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x9320
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
movl $0x4, %edi
callq 0x6e30
movq %rax, -0x18(%rbp)
jmp 0x9458
movl $0xf, %edi
callq 0x7860
testb $0x1, %al
jne 0x93b0
jmp 0x93d8
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x9320
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
movl $0x5, %edi
callq 0x6e30
movq %rax, -0x18(%rbp)
jmp 0x9456
movl $0x10, %edi
callq 0x7860
testb $0x1, %al
jne 0x93e8
jmp 0x9410
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x9320
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
movl $0x6, %edi
callq 0x6e30
movq %rax, -0x18(%rbp)
jmp 0x9454
movl $0x11, %edi
callq 0x7860
testb $0x1, %al
jne 0x9420
jmp 0x9448
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x9320
movq -0x40(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
movl $0x7, %edi
callq 0x6e30
movq %rax, -0x18(%rbp)
jmp 0x9452
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9474
jmp 0x9454
jmp 0x9456
jmp 0x9458
jmp 0x945a
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x15, %edi
callq 0x6f70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0xbd69(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x2c, %edi
callq 0x7980
movl $0x1d, %edi
callq 0x7980
leaq 0xbd67(%rip), %rax      # 0x15240
cmpq $0x0, (%rax)
je 0x94ed
leaq 0xbd5a(%rip), %rax      # 0x15240
movq (%rax), %rax
movb $0x1, 0x28(%rax)
leaq 0xbd4c(%rip), %rax      # 0x15240
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x1c, %edi
callq 0x7860
testb $0x1, %al
jne 0x953e
leaq 0xbd08(%rip), %rax      # 0x15218
movq (%rax), %rdi
callq 0x7ac0
testb $0x1, %al
jne 0x951e
jmp 0x9529
callq 0x9ba0
movq %rax, -0x10(%rbp)
jmp 0x953c
callq 0x9480
movq %rax, -0x10(%rbp)
movl $0x1c, %edi
callq 0x7980
jmp 0x953e
movl $0x1c, %edi
callq 0x77d0
testb $0x1, %al
jne 0x9557
callq 0x9480
movq %rax, -0x18(%rbp)
jmp 0x956f
leaq 0xbcba(%rip), %rax      # 0x15218
movq (%rax), %rsi
movl $0x1, %edi
callq 0x69f0
movq %rax, -0x18(%rbp)
movl $0x1c, %edi
callq 0x7980
xorl %edi, %edi
callq 0x77d0
testb $0x1, %al
jne 0x9586
jmp 0x9591
callq 0x9480
movq %rax, -0x20(%rbp)
jmp 0x9599
movq $0x0, -0x20(%rbp)
movl $0x1e, %edi
callq 0x7980
callq 0x95e0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
leaq 0xbc89(%rip), %rax      # 0x15240
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %r8
callq 0x7600
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %edi, %edi
callq 0x8b40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x99f8
movq -0x20(%rbp), %rdi
callq 0xd3b0
testb $0x1, %al
jne 0x99e9
leaq 0xb842(%rip), %rax      # 0x15218
movq (%rax), %rdi
leaq 0x6c7d(%rip), %rsi      # 0x1065d
movb $0x0, %al
callq 0x5d20
jmp 0x99f6
movq $0x0, -0x8(%rbp)
jmp 0x9ae2
jmp 0x99f8
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd390
testb $0x1, %al
jne 0x9a0f
jmp 0x9a21
movq -0x18(%rbp), %rdi
leaq 0x6c5b(%rip), %rsi      # 0x10675
movb $0x0, %al
callq 0x5d20
leaq 0xb7f0(%rip), %rax      # 0x15218
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0xd, %edi
callq 0x7860
testb $0x1, %al
jne 0x9a42
jmp 0x9ac3
movq -0x20(%rbp), %rdi
callq 0x9af0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd450
testb $0x1, %al
jne 0x9a5e
jmp 0x9a77
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x9a77
movq -0x28(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x9a8f
movq -0x28(%rbp), %rax
cmpl $0x3, (%rax)
je 0x9a8d
movq -0x28(%rbp), %rdi
callq 0x6eb0
movq %rax, -0x28(%rbp)
jmp 0x9a8f
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x73d0
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x6d70
movq %rax, %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x15, %edi
callq 0x6f70
movq %rax, -0x28(%rbp)
jmp 0x9ad0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x73d0
movl $0x1c, %edi
callq 0x7980
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1f, %edi
callq 0x77d0
testb $0x1, %al
jne 0x9b0c
jmp 0x9b89
movq -0x10(%rbp), %rdi
callq 0xd370
testb $0x1, %al
jne 0x9b1b
jmp 0x9b4f
movq -0x10(%rbp), %rdi
callq 0xa770
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x9b45
movq -0x18(%rbp), %rdi
callq 0xdda0
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9b92
movq -0x10(%rbp), %rdi
callq 0xd3b0
testb $0x1, %al
jne 0x9b5e
jmp 0x9b6d
movq -0x10(%rbp), %rdi
callq 0xa850
movq %rax, -0x8(%rbp)
jmp 0x9b92
leaq 0xb6a4(%rip), %rax      # 0x15218
movq (%rax), %rdi
leaq 0x6c4a(%rip), %rsi      # 0x107c8
movb $0x0, %al
callq 0x5d20
jmp 0x9b87
jmp 0x9b92
callq 0x9320
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x40, %edi
callq 0x7860
testb $0x1, %al
jne 0x9bb8
jmp 0x9c1e
movl $0x1, %edi
callq 0x8b40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9bfd
leaq 0xb62c(%rip), %rax      # 0x15218
movq (%rax), %rdi
leaq 0x67ef(%rip), %rsi      # 0x103e5
movb $0x0, %al
callq 0x5d20
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7f60
movl $0x1c, %edi
callq 0x7980
movq $0x0, -0x8(%rbp)
jmp 0x9c47
leaq 0xb5f3(%rip), %rax      # 0x15218
movq (%rax), %rdi
callq 0x7ac0
testb $0x1, %al
jne 0x9c33
jmp 0x9c3e
callq 0x9990
movq %rax, -0x8(%rbp)
jmp 0x9c47
callq 0x95e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1f, %edi
callq 0x7980
movb $0x0, %al
callq 0x3fb0
movq %rax, -0x8(%rbp)
leaq 0xb5bc(%rip), %rax      # 0x15240
cmpq $0x0, (%rax)
je 0x9c98
leaq 0xb5af(%rip), %rax      # 0x15240
movq (%rax), %rax
movb $0x1, 0x28(%rax)
leaq 0xb5a1(%rip), %rax      # 0x15240
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x20, %edi
callq 0x77d0
xorb $-0x1, %al
testb $0x1, %al
jne 0x9cb8
jmp 0x9cd7
callq 0x9ba0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9cd5
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4020
jmp 0x9ca6
movl $0x20, %edi
callq 0x7980
movq -0x10(%rbp), %rcx
leaq 0xb554(%rip), %rax      # 0x15240
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x76a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movb $0x0, %al
callq 0xd250
movq %rax, -0x8(%rbp)
xorl %edi, %edi
callq 0x77d0
testb $0x1, %al
jne 0x9fd0
jmp 0x9fe0
callq 0x7920
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1f, %edi
callq 0x7860
testb $0x1, %al
jne 0xa003
jmp 0xa0ae
movl $0x0, -0x34(%rbp)
movl $0x20, %edi
callq 0x77d0
xorb $-0x1, %al
testb $0x1, %al
jne 0xa01f
jmp 0xa0a4
callq 0x7920
movq %rax, -0x40(%rbp)
movl $0xd, %edi
callq 0x7860
testb $0x1, %al
jne 0xa038
jmp 0xa040
callq 0x78b0
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
callq 0xd280
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x48(%rbp), %rsi
callq 0x7fe0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x48(%rbp), %rsi
callq 0x7e50
movl $0x23, %edi
callq 0x7860
testb $0x1, %al
jne 0xa09f
jmp 0xa0a4
jmp 0xa00a
movl $0x20, %edi
callq 0x7980
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x7e50
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)