LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
callq 0x7205
movq %rax, %rbx
leaq 0xbea8(%rip), %r12      # 0x13228
movq (%r12), %r14
movl (%r14), %eax
movl $0x12, %ebp
cmpl $0x1a, %eax
je 0x739b
cmpl $0x1b, %eax
jne 0x73d0
movl $0x13, %ebp
movq 0x8(%r14), %rax
movq %rax, (%r12)
callq 0x7205
movq %rax, %r15
movq %rbx, %rdi
callq 0xb1f9
movq %r15, %rdi
callq 0xb1f9
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5ab9
movq %rax, %rbx
jmp 0x7380
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7369
movq %rax, %rbx
leaq 0xbe35(%rip), %r15      # 0x13228
leaq 0x5dfe(%rip), %r12      # 0xd1f8
movq (%r15), %r14
movl (%r14), %eax
addl $-0x9, %eax
cmpl $0x3, %eax
ja 0x7474
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x8(%r14), %rax
movq %rax, (%r15)
callq 0x7369
movl $0xb, %edi
jmp 0x7461
movq 0x8(%r14), %rax
movq %rax, (%r15)
callq 0x7369
movl $0xb, %edi
jmp 0x7448
movq 0x8(%r14), %rax
movq %rax, (%r15)
callq 0x7369
movl $0xa, %edi
movq %rax, %rsi
movq %rbx, %rdx
jmp 0x7467
movq 0x8(%r14), %rax
movq %rax, (%r15)
callq 0x7369
movl $0xa, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x5ab9
movq %rax, %rbx
jmp 0x73fa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
callq 0x73dc
movq %rax, %rbx
leaq 0xbd8f(%rip), %r15      # 0x13228
movq (%r15), %r14
movl (%r14), %eax
movl $0x8, %ebp
cmpl $0x7, %eax
je 0x74b3
cmpl $0x8, %eax
jne 0x74d4
movl $0x9, %ebp
movq 0x8(%r14), %rax
movq %rax, (%r15)
callq 0x73dc
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x5ab9
movq %rax, %rbx
jmp 0x7499
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_and_expr
Node *parse_and_expr() {
  Node *node = parse_eq_expr();
  for (;;) {
    Token *op_token = token;
    if (consume_if(TK_AND)) {
      node = new_node_binary_arith(ND_AND, node, parse_eq_expr(), op_token);
      continue;
    }
    return node;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x7483
movq %rax, %rbx
leaq 0xbd2f(%rip), %r12      # 0x13228
movq (%r12), %r14
cmpl $0x16, (%r14)
jne 0x753b
movq 0x8(%r14), %rax
movq %rax, (%r12)
callq 0x7483
movq %rax, %r15
movq %rbx, %rdi
callq 0xb1f9
movq %r15, %rdi
callq 0xb1f9
movl $0xf, %edi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5ab9
movq %rax, %rbx
jmp 0x74f9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_xor_expr
Node *parse_xor_expr() {
  Node *node = parse_and_expr();
  for (;;) {
    Token *op_token = token;
    if (consume_if(TK_XOR)) {
      node = new_node_binary_arith(ND_XOR, node, parse_and_expr(), op_token);
      continue;
    }
    return node;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x74e2
movq %rax, %rbx
leaq 0xbcc7(%rip), %r12      # 0x13228
movq (%r12), %r14
cmpl $0x18, (%r14)
jne 0x75a3
movq 0x8(%r14), %rax
movq %rax, (%r12)
callq 0x74e2
movq %rax, %r15
movq %rbx, %rdi
callq 0xb1f9
movq %r15, %rdi
callq 0xb1f9
movl $0x11, %edi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5ab9
movq %rax, %rbx
jmp 0x7561
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_or_expr
Node *parse_or_expr() {
  Node *node = parse_xor_expr();
  for (;;) {
    Token *op_token = token;
    if (consume_if(TK_OR)) {
      node = new_node_binary_arith(ND_OR, node, parse_xor_expr(), op_token);
      continue;
    }
    return node;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x754a
movq %rax, %rbx
leaq 0xbc5f(%rip), %r12      # 0x13228
movq (%r12), %r14
cmpl $0x17, (%r14)
jne 0x760b
movq 0x8(%r14), %rax
movq %rax, (%r12)
callq 0x754a
movq %rax, %r15
movq %rbx, %rdi
callq 0xb1f9
movq %r15, %rdi
callq 0xb1f9
movl $0x10, %edi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5ab9
movq %rax, %rbx
jmp 0x75c9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_land_expr
Node *parse_land_expr() {
  Node *node = parse_or_expr();
  for (;;) {
    Token *op_token = token;
    if (consume_if(TK_LAND)) {
      node = new_node_binary(ND_LAND, node, parse_or_expr(), op_token);
      continue;
    }
    return node;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x75b2
movq %rax, %rbx
leaq 0xbbfa(%rip), %r15      # 0x13228
movq (%r15), %r14
cmpl $0x14, (%r14)
jne 0x765b
movq 0x8(%r14), %rax
movq %rax, (%r15)
callq 0x75b2
movl $0xc, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x5ab9
movq %rax, %rbx
jmp 0x762e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_lor_expr
Node *parse_lor_expr() {
  Node *node = parse_land_expr();
  for (;;) {
    Token *op_token = token;
    if (consume_if(TK_LOR)) {
      node = new_node_binary(ND_LOR, node, parse_land_expr(), op_token);
      continue;
    }
    return node;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x761a
movq %rax, %rbx
leaq 0xbbb0(%rip), %r15      # 0x13228
movq (%r15), %r14
cmpl $0x15, (%r14)
jne 0x76a5
movq 0x8(%r14), %rax
movq %rax, (%r15)
callq 0x761a
movl $0xd, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x5ab9
movq %rax, %rbx
jmp 0x7678
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7664
movq %rax, %rbx
leaq 0xbb66(%rip), %rax      # 0x13228
movq (%rax), %r14
movl (%r14), %ecx
addl $-0xd, %ecx
cmpl $0x4, %ecx
ja 0x7779
leaq 0x5b2d(%rip), %rdx      # 0xd208
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x76ae
movq %rax, %rdi
callq 0x5b0b
jmp 0x7752
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x76ae
movl $0x7, %edi
jmp 0x7744
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x76ae
movl $0x5, %edi
jmp 0x7744
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x76ae
movl $0x6, %edi
jmp 0x7744
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x76ae
movl $0x4, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x5ab9
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_O3/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 0xba8f(%rip), %r13      # 0x13228
movq (%r13), %rbx
cmpl $0x2c, (%rbx)
movq %rbx, %rax
je 0x77ba
leaq 0x5cba(%rip), %rsi      # 0xd466
movq %rbx, %rdi
xorl %eax, %eax
callq 0x52cd
movq (%r13), %rax
movq 0x8(%rax), %rdi
movq %rdi, (%r13)
cmpl $0x1d, (%rdi)
je 0x77d9
leaq 0x5c98(%rip), %rsi      # 0xd466
xorl %eax, %eax
callq 0x52cd
movq (%r13), %rdi
movq 0x8(%rdi), %rdi
movq %rdi, (%r13)
leaq 0xba68(%rip), %rax      # 0x13250
movq (%rax), %rbp
testq %rbp, %rbp
je 0x77f4
movb $0x1, 0x28(%rbp)
movl (%rdi), %eax
leal -0x34(%rax), %ecx
cmpl $0x8, %ecx
jae 0x78da
callq 0x7ff3
movq %rax, %r14
movq (%r13), %r12
cmpl $0x1c, (%r12)
jne 0x7846
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 0xac48
movq %rax, 0x58(%r15)
jmp 0x784e
callq 0x76ae
movq %rax, %r15
movq (%r13), %rdi
cmpl $0x1c, (%rdi)
je 0x7869
leaq 0x5c08(%rip), %rsi      # 0xd466
xorl %eax, %eax
callq 0x52cd
movq (%r13), %rdi
movq 0x8(%rdi), %rdi
movq %rdi, (%r13)
movl (%rdi), %eax
testl %eax, %eax
je 0x787c
xorl %r12d, %r12d
jmp 0x788a
callq 0x76ae
movq %rax, %r12
movq (%r13), %rdi
movl (%rdi), %eax
cmpl $0x1e, %eax
je 0x78a1
leaq 0x5bd0(%rip), %rsi      # 0xd466
xorl %eax, %eax
callq 0x52cd
movq (%r13), %rdi
movq 0x8(%rdi), %rax
movq %rax, (%r13)
callq 0x7939
leaq 0xb99b(%rip), %rcx      # 0x13250
movq %rbp, (%rcx)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5fa3
leal -0x3d(%rax), %ecx
cmpl $0x2, %ecx
jb 0x7802
cmpl $0x1c, %eax
jne 0x78fb
movq 0x8(%rdi), %r12
movq %r12, (%r13)
xorl %r14d, %r14d
jmp 0x780e
callq 0x6217
testq %rax, %rax
jne 0x7802
callq 0x76ae
movq %rax, %r14
movq (%r13), %rdi
cmpl $0x1c, (%rdi)
je 0x792c
leaq 0x5b45(%rip), %rsi      # 0xd466
xorl %eax, %eax
callq 0x52cd
movq (%r13), %rdi
movq 0x8(%rdi), %r12
movq %r12, (%r13)
jmp 0x780e
// File: /workspace/github_c_makefile_star2_O3/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 0x7095
movq 0x8(%rax), %r14
movq 0x10(%rax), %rbx
testq %r14, %r14
jne 0x7e67
movq %rbx, %rdi
callq 0xad89
testb %al, %al
je 0x7e4f
xorl %ebx, %ebx
jmp 0x7f66
leaq 0xb3d2(%rip), %rax      # 0x13228
movq (%rax), %rdi
leaq 0x5799(%rip), %rsi      # 0xd5f9
xorl %eax, %eax
callq 0x52cd
movq %rbx, %rdi
callq 0xad82
testb %al, %al
je 0x7e84
leaq 0x5797(%rip), %rsi      # 0xd611
movq %r14, %rdi
xorl %eax, %eax
callq 0x52cd
leaq 0xb39d(%rip), %r12      # 0x13228
movq (%r12), %r13
cmpl $0xd, (%r13)
jne 0x7eca
movq 0x8(%r13), %rax
movq %rax, (%r12)
movq %rbx, %rdi
callq 0x7f73
movq %rax, %r15
movq %rbx, %rdi
callq 0xadb1
movl (%r15), %ecx
cmpl $0x2, %ecx
sete %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x7ed9
movl 0x38(%r15), %eax
movl %eax, 0x10(%rbx)
jmp 0x7ee9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5e60
xorl %ebx, %ebx
jmp 0x7f43
cmpl $0x3, %ecx
je 0x7ee9
movq %r15, %rdi
callq 0x5b0b
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5e60
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 0x7f5e
leaq 0x5513(%rip), %rsi      # 0xd466
xorl %eax, %eax
callq 0x52cd
movq (%r12), %rdi
movq 0x8(%rdi), %rax
movq %rax, (%r12)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb2aa(%rip), %r14      # 0x13228
movq (%r14), %rax
cmpl $0x1f, (%rax)
jne 0x7fb3
movq %rdi, %rbx
callq 0xad7b
movq %rbx, %rdi
testb %al, %al
je 0x7fbf
callq 0x8b96
movq %rax, %r14
cmpl $0x0, 0x10(%rbx)
jne 0x7fe8
movq %r14, %rdi
callq 0xb225
movl 0x10(%rax), %eax
movl %eax, 0x10(%rbx)
jmp 0x7fe8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x76ae
callq 0xad89
testb %al, %al
je 0x7fd7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8c75
movq (%r14), %rdi
leaq 0x5783(%rip), %rsi      # 0xd764
xorl %eax, %eax
callq 0x52cd
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb229(%rip), %rbx      # 0x13228
movq (%rbx), %rdi
movl (%rdi), %eax
leal -0x34(%rax), %ecx
cmpl $0x8, %ecx
jae 0x8016
popq %rbx
popq %r14
popq %r15
jmp 0x7e1f
leal -0x3d(%rax), %ecx
cmpl $0x2, %ecx
jb 0x800c
cmpl $0x40, %eax
jne 0x806a
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
movl $0x1, %edi
callq 0x7095
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x807e
movq 0x10(%rax), %r15
movl $0x1, %edi
movl $0x18, %esi
callq 0x10d0
leaq 0xb209(%rip), %rcx      # 0x13260
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x8(%rax)
movq %rax, (%rcx)
jmp 0x808f
callq 0x6217
testq %rax, %rax
jne 0x800c
popq %rbx
popq %r14
popq %r15
jmp 0x7939
movq (%rbx), %rdi
leaq 0x52f9(%rip), %rsi      # 0xd381
xorl %eax, %eax
callq 0x52cd
movq (%rbx), %rdi
cmpl $0x1c, (%rdi)
je 0x80a8
leaq 0x53c8(%rip), %rsi      # 0xd466
xorl %eax, %eax
callq 0x52cd
movq (%rbx), %rdi
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb161(%rip), %r14      # 0x13228
movq (%r14), %rdi
cmpl $0x1f, (%rdi)
je 0x80e0
leaq 0x5390(%rip), %rsi      # 0xd466
xorl %eax, %eax
callq 0x52cd
movq (%r14), %rdi
movq 0x8(%rdi), %rax
movq %rax, (%r14)
xorl %eax, %eax
callq 0x3f0c
movq %rax, %rbx
leaq 0xb158(%rip), %r15      # 0x13250
movq (%r15), %r12
testq %r12, %r12
je 0x811d
movb $0x1, 0x28(%r12)
jmp 0x811d
callq 0x7ff3
testq %rax, %rax
je 0x811d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3f3e
movq (%r14), %rax
cmpl $0x20, (%rax)
jne 0x8108
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
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_enum_specifier
Type *parse_enum_specifier() {
  Type *type = new_type_enum();
  if (peek(TK_IDENT)) type->tag_name = consume_ident();
  MemberInfo head;
  head.next = NULL;
  MemberInfo *cursor = &head;
  if (consume_if(TK_OP_BRACE)) {
    int i = 0;
    while (!peek(TK_CL_BRACE)) {
      Token *ident = consume_ident();
      // initializer
      if (consume_if(TK_ASSIGN)) {
        i = consume_number();
      }
      Type *new = new_type_enum_el(ident, i++);
      cursor->next = new_member_info(new->tag_name, new);
      cursor = cursor->next;
      new_tag(new->tag_name, new);
      if (!consume_if(TK_COMMA)) break;
    }
    expect(TK_CL_BRACE);
  }
  type->member = head.next;
  new_tag(type->tag_name, type);
  return type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
callq 0xad13
movq %rax, %r15
leaq 0xae3c(%rip), %rbp      # 0x13228
movq (%rbp), %r14
movl (%r14), %eax
testl %eax, %eax
jne 0x8408
movq 0x8(%r14), %rcx
movq %rcx, (%rbp)
movq %r14, 0x30(%r15)
movl (%rcx), %eax
movq %rcx, %r14
movq $0x0, 0x10(%rsp)
xorl %ecx, %ecx
cmpl $0x1f, %eax
jne 0x8510
movq %r15, 0x8(%rsp)
leaq 0x10(%rsp), %rbx
xorl %r12d, %r12d
movq 0x8(%r14), %r14
movq %r14, (%rbp)
movl (%r14), %eax
testl %eax, %eax
je 0x8456
cmpl $0x20, %eax
je 0x84fe
movq %r14, %rdi
leaq 0x4f36(%rip), %rsi      # 0xd381
xorl %eax, %eax
callq 0x52cd
movq (%rbp), %r14
movq 0x8(%r14), %rax
movq %rax, (%rbp)
cmpl $0xd, (%rax)
jne 0x8473
movq 0x8(%rax), %rax
movq %rax, (%rbp)
callq 0x6107
movq %rax, %r12
movq %r14, %rdi
movl %r12d, %esi
callq 0xad2b
movq %rax, %r14
movq 0x30(%rax), %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x10d0
movq %rax, %r13
movq %r14, 0x10(%rax)
movq %r15, 0x8(%rax)
movq %rax, (%rbx)
testq %r15, %r15
je 0x84ce
movl $0x1, %edi
movl $0x18, %esi
callq 0x10d0
leaq 0xad9b(%rip), %rdx      # 0x13258
movq (%rdx), %rcx
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, (%rdx)
incl %r12d
movq (%rbp), %r14
movl (%r14), %eax
movq %r13, %rbx
cmpl $0x23, %eax
je 0x8429
cmpl $0x20, %eax
je 0x84fe
leaq 0x4f76(%rip), %rsi      # 0xd466
movq %r14, %rdi
xorl %eax, %eax
callq 0x52cd
movq (%rbp), %r14
movq 0x8(%rsp), %r15
movq 0x8(%r14), %rax
movq %rax, (%rbp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%r15)
movq 0x30(%r15), %rbx
testq %rbx, %rbx
je 0x8544
movl $0x1, %edi
movl $0x18, %esi
callq 0x10d0
leaq 0xad25(%rip), %rcx      # 0x13258
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, (%rcx)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_func_definition
Node *parse_func_definition(MemberInfo *ty_ident) {
  Node *decl;
  Token *ident = ty_ident->ident;
  Type *type = ty_ident->type;
  cur_fn = new_func(ident, type, NULL);
  // function definition
  Vector *params = vec_new();
  MemberInfo *cursor = type->params;
  while (cursor) {
    vec_push(params, new_node_lvar(new_lvar(cursor->ident, cursor->type),
                                   cursor->ident));
    cursor = cursor->next;
  }

  Node *body = parse_block();
  int max_offset;
  if (type->variadic) {
    max_offset = 128;
  } else {
    max_offset = 32;
  };
  if (locals) max_offset = locals->offset;
  decl = new_node_fdecl(ident, params, max_offset, body, type);
  cur_fn->body = decl;
  return decl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
movl $0x1, %edi
movl $0x28, %esi
callq 0x10d0
leaq 0xa7b7(%rip), %rcx      # 0x13268
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, (%rcx)
movq %rax, 0xa7a7(%rip)      # 0x13270
xorl %eax, %eax
callq 0x3f0c
movq %rax, %rbx
movq 0x18(%r12), %r13
testq %r13, %r13
je 0x8b27
movq 0x8(%r13), %rdi
movq 0x10(%r13), %rsi
callq 0x5e60
movq %rax, %r14
movq 0x8(%r13), %rbp
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x18, (%rax)
movq %r14, 0x30(%rax)
movq %rbp, 0x50(%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x58(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3f3e
movq (%r13), %r13
jmp 0x8ad8
callq 0x80b7
cmpb $0x0, 0x38(%r12)
movl $0x80, %ecx
movl $0x20, %ebp
cmovnel %ecx, %ebp
movq %rax, %r14
leaq 0xa6ff(%rip), %rax      # 0x13248
movq (%rax), %rax
testq %rax, %rax
je 0x8b54
movl 0x18(%rax), %ebp
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movl $0x27, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x48(%rax)
movl %ebp, 0x38(%rax)
movq %r15, 0x50(%rax)
movq %r12, 0x58(%rax)
movq 0xa6ed(%rip), %rcx      # 0x13270
movq %rax, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_array_initializer
Node *parse_array_initializer(Type *l_type) {
  Token *op_token = token;
  expect(TK_OP_BRACE);
  Vector *vec = vec_new();
  Type *ary_of = l_type->ptr_to;
  while (!peek(TK_CL_BRACE)) {
    Node *init = parse_initializer(ary_of);
    vec_push(vec, init);
    if (!consume_if(TK_COMMA)) break;
  }
  expect(TK_CL_BRACE);
  Node *node = new_node(ND_INIT, op_token);
  node->nodes = vec;
  node->type = new_type_array(ary_of, vec_len(vec));
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xa680(%rip), %r12      # 0x13228
movq (%r12), %rbx
cmpl $0x1f, (%rbx)
movq %rbx, %rax
je 0x8bc9
leaq 0x48ab(%rip), %rsi      # 0xd466
movq %rbx, %rdi
xorl %eax, %eax
callq 0x52cd
movq (%r12), %rax
movq 0x8(%rax), %rax
movq %rax, (%r12)
xorl %eax, %eax
callq 0x3f0c
movq %rax, %r15
movq 0x8(%r14), %r14
movq (%r12), %rdi
cmpl $0x20, (%rdi)
je 0x8c27
movq %r14, %rdi
callq 0x7f73
movq %r15, %rdi
movq %rax, %rsi
callq 0x3f3e
movq (%r12), %rdi
movl (%rdi), %eax
cmpl $0x23, %eax
jne 0x8c10
movq 0x8(%rdi), %rdi
movq %rdi, (%r12)
jmp 0x8be3
cmpl $0x20, %eax
je 0x8c27
leaq 0x484a(%rip), %rsi      # 0xd466
xorl %eax, %eax
callq 0x52cd
movq (%r12), %rdi
movq 0x8(%rdi), %rax
movq %rax, (%r12)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %r12
movl $0x3, (%rax)
movq %rbx, 0x50(%rax)
movq %r15, 0x48(%rax)
movq %r15, %rdi
callq 0x3f3a
movq %r14, %rdi
movl %eax, %esi
callq 0xacaf
movq %rax, 0x58(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/parse.c
// Function: parse_struct_initializer
Node *parse_struct_initializer(Type *l_type) {
  Token *op_token = token;
  expect(TK_OP_BRACE);
  Vector *vec = vec_new();
  MemberInfo *member = l_type->member;
  while (!peek(TK_CL_BRACE)) {
    Node *init = parse_initializer(member->type);
    vec_push(vec, init);
    if (!consume_if(TK_COMMA)) break;
    member = member->next;
  }
  expect(TK_CL_BRACE);
  Node *node = new_node(ND_INIT, op_token);
  node->nodes = vec;
  node->type = new_type_struct();
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0xa5a1(%rip), %r12      # 0x13228
movq (%r12), %rbx
cmpl $0x1f, (%rbx)
movq %rbx, %rax
je 0x8ca8
leaq 0x47cc(%rip), %rsi      # 0xd466
movq %rbx, %rdi
xorl %eax, %eax
callq 0x52cd
movq (%r12), %rax
movq 0x8(%rax), %rax
movq %rax, (%r12)
xorl %eax, %eax
callq 0x3f0c
movq %rax, %r14
movq (%r12), %rdi
cmpl $0x20, (%rdi)
je 0x8d0f
addq $0x20, %r15
movq (%r15), %r15
movq 0x10(%r15), %rdi
callq 0x7f73
movq %r14, %rdi
movq %rax, %rsi
callq 0x3f3e
movq (%r12), %rdi
movl (%rdi), %eax
cmpl $0x23, %eax
jne 0x8cf8
movq 0x8(%rdi), %rdi
movq %rdi, (%r12)
cmpl $0x20, (%rdi)
jne 0x8cc7
jmp 0x8d0f
cmpl $0x20, %eax
je 0x8d0f
leaq 0x4762(%rip), %rsi      # 0xd466
xorl %eax, %eax
callq 0x52cd
movq (%r12), %rdi
movq 0x8(%rdi), %rax
movq %rax, (%r12)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10d0
movq %rax, %r15
movl $0x3, (%rax)
movq %rbx, 0x50(%rax)
movq %r14, 0x48(%rax)
xorl %eax, %eax
callq 0xacfb
movq %rax, 0x58(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/pp.c
// Function: pp
void pp() {
  Macro *m;
  for (Token *t = token; t; t = t->next) {
    // print_token(stderr, t);
    if (t->kind != TK_IDENT) continue;
    if (!(m = find_macro(t))) continue;
    Macro args_head;
    args_head.next = NULL;
    Macro *args = &args_head;
    if (m->params) {
      check_params(m, t, &args);
    }
    // for(Macro *args = args_head.next; args; args = args->next)
    // print_tokens(stderr, args->params);
    if (!m->subst) {
      Token *next_token = t->next;
      *t = *next_token;
      t = next_token;
      continue;
    }

    Token *next_token = t->next;
    *t = *(m->subst);
    while (t->next) {
      if (t->kind == TK_IDENT) {
        for (Token *param = m->params; param; param = param->next) {
          if (cmp_token(t, param)) {
            int i = param->num_val;
            // fprintf(stderr, "find: %d", i);
            // print_token(stderr, t);
            for (Macro *args = args_head.next; args; args = args->next) {
              if (i-- == 0) {
                Token *next = t->next;
                // copy_token(args->params, t);
                *t = *args->params;
                while (t->next) t - t->next;
                t->next = next;
                break;
              }
            }
            // fprintf(stderr, "\n");
            break;
          }
        }
      }
      t = t->next;
    }
    t->next = next_token;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x9f4f(%rip), %rax      # 0x13228
movq (%rax), %r14
testq %r14, %r14
je 0x9415
leaq 0x8(%rsp), %r13
cmpl $0x0, (%r14)
je 0x92fe
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x92ea
jmp 0x9415
movq %r14, %rdi
callq 0x965a
testq %rax, %rax
je 0x92f0
movq %rax, %r15
movq $0x0, 0x8(%rsp)
movq %r13, (%rsp)
cmpq $0x0, 0x10(%rax)
je 0x9330
movq %r15, %rdi
movq %r14, %rsi
movq %rsp, %rdx
callq 0x910c
movq 0x18(%r15), %rax
movq 0x8(%r14), %rbp
testq %rax, %rax
je 0x93f1
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm0, (%r14)
movups %xmm2, 0x20(%r14)
movups %xmm1, 0x10(%r14)
cmpq $0x0, 0x8(%r14)
je 0x93e8
leaq 0x8(%r14), %rbx
cmpl $0x0, (%r14)
je 0x937f
movq (%rbx), %r14
leaq 0x8(%r14), %rbx
cmpq $0x0, 0x8(%r14)
jne 0x9369
jmp 0x93e8
movq 0x10(%r15), %r12
testq %r12, %r12
je 0x936f
movq %r14, %rdi
movq %r12, %rsi
callq 0x618e
testb %al, %al
jne 0x939e
movq 0x8(%r12), %r12
jmp 0x9383
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x936f
movl 0x10(%r12), %ecx
incl %ecx
decl %ecx
je 0x93bd
movq (%rax), %rax
testq %rax, %rax
jne 0x93af
jmp 0x936f
movq (%rbx), %rcx
movq 0x10(%rax), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%r14)
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
cmpq $0x0, (%rbx)
jne 0x9413
movq %rcx, (%rbx)
jmp 0x936f
movq %rbp, 0x8(%r14)
jmp 0x92f0
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups 0x20(%rbp), %xmm2
movups %xmm2, 0x20(%r14)
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
movq %rbp, %r14
jmp 0x92f0
jmp 0x9413
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/tokenize.c
// Function: new_file_info
FileInfo *new_file_info(char *file_name, char *start) {
  FileInfo *fi = calloc(1, sizeof(FileInfo));
  fi->next = file_informations;
  fi->file_name = file_name;
  fi->start = start;
  if (file_informations) {
    fi->no = file_informations->no + 1;
  } else {
    fi->no = 1;
  };
  file_informations = fi;
  return fi;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x28, %esi
callq 0x10d0
leaq 0x9ccc(%rip), %rcx      # 0x13208
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
testq %rdx, %rdx
je 0x9556
movl 0x20(%rdx), %edx
incl %edx
jmp 0x955b
movl $0x1, %edx
movl %edx, 0x20(%rax)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/tokenize.c
// Function: new_macro
Macro *new_macro(Token *token, Token *params, Token *subst) {
  Macro *m = calloc(1, sizeof(Macro));
  m->token = token;
  m->params = params;
  m->subst = subst;
  m->next = macros;
  macros = m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x10d0
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq 0x9ce7(%rip), %rcx      # 0x13280
movq %rcx, (%rax)
movq %rax, 0x9cdd(%rip)      # 0x13280
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/tokenize.c
// Function: dup_tokens
Token *dup_tokens(Token *src) {
  Token head;
  head.next = NULL;
  Token *t = &head;
  for (; src; src = src->next) {
    t->next = dup_token(src);
    t = t->next;
  }
  return head.next;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq $0x0, 0x10(%rsp)
testq %rdi, %rdi
je 0x960a
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x1, %edi
movl $0x30, %esi
callq 0x10d0
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rbx
movq %rax, %r14
testq %rbx, %rbx
jne 0x95c6
movq 0x10(%rsp), %rax
jmp 0x960c
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/tokenize.c
// Function: find_macro
Macro *find_macro(Token *token) {
  for (Macro *m = macros; m; m = m->next) {
    if (token->len == m->token->len &&
        strncmp(token->str, m->token->str, token->len) == 0) {
      return dup_macro(m);
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x9c1a(%rip), %rbx      # 0x13280
testq %rbx, %rbx
je 0x9698
movq %rdi, %r14
movslq 0x28(%rdi), %r15
movq 0x8(%rbx), %rax
cmpl 0x28(%rax), %r15d
jne 0x9690
movq 0x20(%r14), %rdi
movq 0x20(%rax), %rsi
movq %r15, %rdx
callq 0x1050
testl %eax, %eax
je 0x96a0
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x9672
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9614
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/type.c
// Function: new_type_func
Type *new_type_func(Type *return_type) {
  Type *type = calloc(1, sizeof(Type));
  type->ty = FUNC;
  type->ptr_to = return_type;
  type->variadic = false;
  return type;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x40, %esi
callq 0x10d0
movl $0xb, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/type.c
// Function: get_common_type
Type *get_common_type(Type *ty1, Type *ty2) {
  if (sizeof_type(ty1) < 4) ty1 = new_type_int();
  if (sizeof_type(ty2) < 4) ty2 = new_type_int();

  if (is_signed(ty1) == is_signed(ty2)) {
    if (sizeof_type(ty1) < sizeof_type(ty2)) {
      return ty2;
    } else {
      return ty1;
    }
  }

  if (is_signed(ty1)) {
    if (sizeof_type(ty2) >= sizeof_type(ty1)) {
      return ty2;
    } else {
      return ty1;
    };
  } else {
    if (sizeof_type(ty1) >= sizeof_type(ty2)) {
      return ty1;
    } else {
      return ty2;
    };
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xae77
cmpl $0x4, %eax
leaq 0x8489(%rip), %r15      # 0x13288
cmovlq %r15, %rbx
movq %r14, %rdi
callq 0xae77
cmpl $0x4, %eax
cmovlq %r15, %r14
movl (%rbx), %eax
decl %eax
testl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
sete %cl
movl (%r14), %edx
decl %edx
testl $0xfffffff9, %edx       # imm = 0xFFFFFFF9
sete %dl
xorb %cl, %dl
je 0xae37
testl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
je 0xae5d
movq %rbx, %rdi
callq 0xae77
movl %eax, %ebp
movq %r14, %rdi
callq 0xae77
cmpl %eax, %ebp
cmovlq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xae77
movl %eax, %ebp
movq %rbx, %rdi
callq 0xae77
cmpl %eax, %ebp
cmovgeq %r14, %rbx
jmp 0xae4f
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/type.c
// Function: sizeof_type
int sizeof_type(Type *type) {
  switch (type->ty) {
    case VOID:
      return 0;
    case CHAR:
    case BOOL:
      return 1;
    case SHORT:
    case USHORT:
      return 2;
    case INT:
    case UINT:
    case ENUM_EL:
    case ENUM:
      return 4;
    case PTR:
    case LONG:
    case ULONG:
      return 8;
    case ARRAY:
      return type->array_size * sizeof_type(type->ptr_to);
    case STRUCT:
      return sizeof_struct(type);
    default:
      error("Internal error: can not calculate size of unknown type ID=%d",
            type->ty);
  }
}

// Assembly:
pushq %rbx
movl $0x1, %ebx
movl (%rdi), %esi
cmpl $0xa, %esi
jne 0xae8e
imull 0x10(%rdi), %ebx
movq 0x8(%rdi), %rdi
jmp 0xae7d
cmpl $0xe, %esi
ja 0xaecc
movl %esi, %eax
leaq 0x2be0(%rip), %rcx      # 0xda7c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, %eax
jmp 0xaeda
movl $0x8, %eax
jmp 0xaeda
movl $0x2, %eax
jmp 0xaeda
movl $0x1, %eax
jmp 0xaeda
xorl %eax, %eax
jmp 0xaeda
callq 0xafa0
jmp 0xaeda
leaq 0x2d0e(%rip), %rdi      # 0xdbe1
xorl %eax, %eax
callq 0x508c
imull %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/type.c
// Function: alignof_struct
int alignof_struct(Type *type) {
  MemberInfo *cursor = type->member;
  TagName *tag = find_tag(type->tag_name);
  if (!tag) {
    if (!type->member) error("anonymous struct with no members.");
  } else
    cursor = tag->type->member;
  int align = 0;
  while (cursor) {
    int a = alignof_type(cursor->type);
    if (a > align) align = a;
    cursor = cursor->next;
  }
  return align;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x30(%rdi), %rdi
callq 0x647f
testq %rax, %rax
je 0xaf0c
movq 0x10(%rax), %rax
movq 0x20(%rax), %r14
jmp 0xaf21
cmpq $0x0, 0x20(%rbx)
jne 0xaf21
leaq 0x2c66(%rip), %rdi      # 0xdb80
xorl %eax, %eax
callq 0x508c
xorl %ebx, %ebx
testq %r14, %r14
je 0xaf3b
movq 0x10(%r14), %rdi
callq 0xaf45
cmpl %ebx, %eax
cmovgl %eax, %ebx
movq (%r14), %r14
jmp 0xaf23
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/type.c
// Function: alignof_type
int alignof_type(Type *type) {
  switch (type->ty) {
    case VOID:
      return 0;
    case CHAR:
    case BOOL:
      return 1;
    case SHORT:
    case USHORT:
      return 2;
    case INT:
    case UINT:
    case ENUM_EL:
    case ENUM:
      return 4;
    case PTR:
    case LONG:
    case ULONG:
      return 8;
    case ARRAY:
      return alignof_type(type->ptr_to);
    case STRUCT:
      return alignof_struct(type);
    default:
      error("Internal error: can not calculate align of unknown type ID=%d.",
            type->ty);
  }
}

// Assembly:
pushq %rax
movl (%rdi), %esi
cmpl $0xa, %esi
jne 0xaf53
movq 0x8(%rdi), %rdi
jmp 0xaf46
cmpl $0xe, %esi
ja 0xaf90
movl %esi, %eax
leaq 0x2b57(%rip), %rcx      # 0xdab8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, %eax
jmp 0xaf9e
movl $0x8, %eax
jmp 0xaf9e
movl $0x2, %eax
jmp 0xaf9e
movl $0x1, %eax
jmp 0xaf9e
xorl %eax, %eax
jmp 0xaf9e
popq %rax
jmp 0xaee9
leaq 0x2c0b(%rip), %rdi      # 0xdba2
xorl %eax, %eax
callq 0x508c
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/type.c
// Function: sizeof_struct
int sizeof_struct(Type *type) {
  MemberInfo *cursor;
  TagName *tag = find_tag(type->tag_name);
  if (!tag) {
    if (!type->member) error("anonymous struct with no members.");
    cursor = type->member;
  } else
    cursor = tag->type->member;
  int size = 0;
  while (cursor) {
    size = align_to(size, alignof_type(cursor->type));
    size += sizeof_type(cursor->type);  // sizeof_type(cursor);
    cursor = cursor->next;
  }
  return align_to(size, alignof_type(type));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x647f
testq %rax, %rax
je 0xafd1
movq 0x10(%rax), %r14
addq $0x20, %r14
movq (%r14), %r12
testq %r12, %r12
jne 0xafda
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0xb012
movq 0x20(%rbx), %r12
testq %r12, %r12
je 0xb02e
xorl %r14d, %r14d
movq 0x10(%r12), %rdi
callq 0xaf45
movl %eax, %r15d
leal (%r14,%r15), %eax
decl %eax
negl %r15d
andl %eax, %r15d
movq 0x10(%r12), %rdi
callq 0xae77
movl %eax, %r14d
addl %r15d, %r14d
movq (%r12), %r12
testq %r12, %r12
jne 0xafdd
decl %r14d
movq %rbx, %rdi
callq 0xaf45
addl %eax, %r14d
negl %eax
andl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x20(%rbx), %r14
leaq 0x2b47(%rip), %rdi      # 0xdb80
xorl %eax, %eax
callq 0x508c
jmp 0xafc1
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/type.c
// Function: is_identical_type
bool is_identical_type(Type *l_type, Type *r_type) {
  if (l_type->ty != r_type->ty) return false;
  if (is_void(l_type) && is_void(r_type)) return true;
  if (is_arith(l_type)) return true;
  if (is_array(l_type))
    return is_identical_type(l_type->ptr_to, r_type->ptr_to);
  if (is_struct(l_type)) {
    MemberInfo *l_mem = l_type->member;
    MemberInfo *r_mem = r_type->member;
    while (l_mem && r_mem) {
      if (!is_identical_type(l_mem->type, r_mem->type)) return false;
      l_mem = l_mem->next;
      r_mem = r_mem->next;
    }
    return !r_mem && !l_mem;
  }
  if (is_ptr(l_type)) {
    return is_identical_type(l_type->ptr_to, r_type->ptr_to);
  }
  if (is_func(l_type)) {
    return is_identical_type(l_type->ptr_to, r_type->ptr_to);
  }
  return false;
}

// Assembly:
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0xb06e
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leal -0x9(%rax), %ecx
cmpl $0x3, %ecx
jae 0xb071
movq 0x8(%rbx), %rbx
movq 0x8(%r14), %r14
movl (%r14), %eax
cmpl (%rbx), %eax
je 0xb055
jmp 0xb084
xorl %eax, %eax
retq
cmpl $0x9, %eax
jae 0xb07a
movb $0x1, %al
jmp 0xb086
cmpl $0xc, %eax
je 0xb08e
cmpl $0xd, %eax
je 0xb076
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x20, %r14
addq $0x20, %rbx
movq (%rbx), %rbx
movq (%r14), %r14
testq %r14, %r14
je 0xb0bd
testq %rbx, %rbx
je 0xb0bd
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0xb045
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0xb096
jmp 0xb086
orq %r14, %rbx
sete %al
jmp 0xb086
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/type.c
// Function: is_compatible_type
bool is_compatible_type(Type *l_type, Type *r_type) {
  if (is_arith(l_type) && is_arith(r_type)) return true;
  // if (is_arith(l_type) && !is_arith(r_type)) return false;
  // if (!is_arith(l_type) && is_arith(r_type)) return false;
  if (is_ptr(l_type) && is_ptr(r_type)) {
    if (is_void(l_type->ptr_to) || is_void(r_type->ptr_to)) return true;
    return is_identical_type(l_type->ptr_to, r_type->ptr_to);
  }
  if (is_func(l_type) && is_func(r_type))
    return is_identical_type(l_type, r_type);
  return false;
}

// Assembly:
movl (%rdi), %ecx
leal -0x1(%rcx), %eax
cmpl $0x8, %eax
jae 0xb0f5
movl (%rsi), %edx
leal -0x1(%rdx), %r8d
cmpl $0xd, %r8d
jae 0xb0e9
movb $0x1, %al
movl $0x10ff, %r9d           # imm = 0x10FF
btl %r8d, %r9d
jb 0xb11f
cmpl $0xb, %ecx
je 0xb122
cmpl $0x9, %ecx
je 0xb106
jmp 0xb12c
cmpl $0xd, %ecx
je 0xb0cf
cmpl $0xb, %ecx
je 0xb120
cmpl $0x9, %ecx
jne 0xb12c
movl (%rsi), %edx
cmpl $0x9, %edx
jne 0xb12c
movq 0x8(%rdi), %rdi
movb $0x1, %al
cmpl $0x0, (%rdi)
je 0xb11f
movq 0x8(%rsi), %rsi
cmpl $0x0, (%rsi)
jne 0xb127
retq
movl (%rsi), %edx
cmpl $0xb, %edx
jne 0xb12c
jmp 0xb045
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/sisshiki1969[P]monocc/src/type.c
// Function: is_assignable_type
bool is_assignable_type(Type *l_type, Type *r_type) {
  if (is_array(l_type)) {
    if (is_array(r_type)) {
      return true;
    }
    l_type = l_type->ptr_to;
  }
  if (is_void(l_type) || is_void(r_type)) return false;
  if (is_arith(l_type) && is_arith(r_type)) return true;
  if (is_ptr(l_type) && is_arith(r_type)) return true;
  if (is_ptr(l_type) && is_ptr(r_type) && is_void(r_type->ptr_to)) return true;
  while (l_type) {
    if (l_type->ty != r_type->ty) return false;
    if (l_type->ty != PTR && l_type->ty != ARRAY) return true;
    l_type = l_type->ptr_to;
    r_type = r_type->ptr_to;
  }
  error("Internal error: Invalid type structure.");
}

// Assembly:
pushq %rax
movl (%rdi), %ecx
cmpl $0xa, %ecx
jne 0xb144
movb $0x1, %al
cmpl $0xa, (%rsi)
je 0xb17a
movq 0x8(%rdi), %rdi
movl (%rdi), %ecx
testl %ecx, %ecx
je 0xb178
movl (%rsi), %edx
testl %edx, %edx
je 0xb178
leal -0x1(%rcx), %eax
cmpl $0x8, %eax
jae 0xb17e
cmpl $0xe, %edx
jae 0xb171
leal -0x1(%rdx), %r8d
movb $0x1, %al
movzbl %r8b, %r8d
movl $0x10ff, %r9d           # imm = 0x10FF
btl %r8d, %r9d
jb 0xb17a
cmpl $0x9, %ecx
jne 0xb1a7
jmp 0xb18a
xorl %eax, %eax
andb $0x1, %al
popq %rcx
retq
cmpl $0x9, %ecx
je 0xb18a
cmpl $0xd, %ecx
jne 0xb1a7
jmp 0xb156
movb $0x1, %al
leal -0x1(%rdx), %ecx
cmpl $0x8, %ecx
jb 0xb17a
cmpl $0xd, %edx
je 0xb17a
cmpl $0x9, %edx
jne 0xb1a7
movq 0x8(%rsi), %rcx
cmpl $0x0, (%rcx)
je 0xb17a
movl (%rdi), %ecx
cmpl (%rsi), %ecx
sete %al
jne 0xb17a
addl $-0x9, %ecx
cmpl $0x1, %ecx
ja 0xb17a
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
testq %rdi, %rdi
jne 0xb1a7
leaq 0x2a52(%rip), %rdi      # 0xdc1e
xorl %eax, %eax
callq 0x508c
jmp 0xb17a
// File: /workspace/github_c_makefile_star2_O3/marcespie[P]unix-samples/lab/soshutdown.c
// Function: main
int
main()
{
	struct addrinfo hints, *res, *res0;
	int error;
	int s = -1;

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE;

	error = getaddrinfo("localhost", "ssh", &hints, &res0);
	if (error)
		errx(1, "%s", gai_strerror(error));
	for (res = res0; res; res = res->ai_next) {
		s = socket(res->ai_family, res->ai_socktype,
		    res->ai_protocol);
		if (s == -1)
			continue;
		if (connect(s, res->ai_addr, res->ai_addrlen) == -1) {
			warn("connect");
			close(s);
			s = -1;
			continue;
		}
		break;
	}
	if (s == -1)
		fprintf(stderr, "no ssh running here\n");
	int pid;

	errwrap(pid = fork());
	// so this is the fun thing: most fds in the system are shared
	// between processes: when you call close(), the underlying 
	// file/socket does NOT get closed
	if (pid == 0) {
		shutdown(s, SHUT_WR);
		exit(0);
	}
	pause();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movl $0x1, %eax
movl %eax, 0x8(%rdx)
movl %eax, (%rdx)
leaq 0xdac(%rip), %rdi       # 0x2004
leaq 0xdaf(%rip), %rsi       # 0x200e
leaq 0x8(%rsp), %rcx
callq 0x10d0
testl %eax, %eax
jne 0x12ec
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x12c4
leaq 0xd97(%rip), %rbx       # 0x2015
movl 0x4(%r14), %edi
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
callq 0x10f0
cmpl $-0x1, %eax
je 0x12bb
movl %eax, %ebp
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movl %eax, %edi
callq 0x10b0
cmpl $-0x1, %eax
jne 0x12ce
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
movl %ebp, %edi
callq 0x1070
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x127e
callq 0x1110
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
callq 0x10e0
testl %eax, %eax
je 0x1309
cmpl $-0x1, %eax
je 0x131c
callq 0x1080
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %edi
callq 0x1060
leaq 0xd18(%rip), %rsi       # 0x2012
movl $0x1, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
movl %ebp, %edi
movl $0x1, %esi
callq 0x1040
xorl %edi, %edi
callq 0x10a0
leaq 0xd0f(%rip), %rsi       # 0x2032
movl $0x1, %edi
xorl %eax, %eax
callq 0x1090