LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::ArrayInitVal::PrintNode(int, std::ostream&)
void ArrayInitVal::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "ArrayInitVal" << LINE_NO << std::endl;
  if (this->is_exp_ && nullptr != this->value_) {
    this->value_->PRINT_NODE;
  }
  for (const auto &ele : this->initval_list_) {
    ele->PRINT_NODE;
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %edi
movq 0x30(%rsp), %rsi
callq 0x11640
movq 0x30(%rsp), %rdi
leaq 0xe6324(%rip), %rsi     # 0xfa5ba
callq 0x8330
movq %rax, %rdi
leaq 0xe7e54(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe61a7(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x137cad(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
testb $0x1, 0xc(%rax)
je 0x1430b
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
je 0x1430b
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x3c(%rsp), %esi
addl $0x1, %esi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x14f70
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x14fa0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x14fd0
testb $0x1, %al
jne 0x1434c
jmp 0x14381
leaq 0x20(%rsp), %rdi
callq 0x15010
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0x3c(%rsp), %esi
addl $0x1, %esi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x20(%rsp), %rdi
callq 0x15020
jmp 0x14337
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::FunctionFormalParameter::PrintNode(int, std::ostream&)
void FunctionFormalParameter::PrintNode(int indentation,
                                        std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "FunctionFormalParameter Type: " << TYPE_STRING(this->type_)
          << LINE_NO << std::endl;
  this->name_.PRINT_NODE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %edi
movq 0x20(%rsp), %rsi
callq 0x11640
movq 0x20(%rsp), %rdi
leaq 0xe6151(%rip), %rsi     # 0xfa5c7
callq 0x8330
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
cmpl $0x121, 0xc(%rax)       # imm = 0x121
jne 0x1449f
leaq 0xe666e(%rip), %rax     # 0xfab06
movq %rax, 0x8(%rsp)
jmp 0x144c4
movq 0x10(%rsp), %rax
movl 0xc(%rax), %edx
leaq 0xe7c60(%rip), %rax     # 0xfc10e
leaq 0xe6068(%rip), %rcx     # 0xfa51d
cmpl $0x122, %edx            # imm = 0x122
cmoveq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x8330
movq %rax, %rdi
leaq 0xe7c1c(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe5f6f(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x137a75(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x2c(%rsp), %esi
addl $0x1, %esi
movq 0x20(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x38, %rsp
retq
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::FunctionFormalParameterList::PrintNode(int, std::ostream&)
void FunctionFormalParameterList::PrintNode(int indentation,
                                            std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "FunctionFormalParameterList" << LINE_NO << std::endl;
  if (this->arg_list_.empty()) {
    ++indentation;
    PRINT_INDENT;
    outfile << "Empty" << std::endl;
  } else {
    for (const auto &ele : this->arg_list_) {
      ele->PRINT_NODE;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %edi
movq 0x30(%rsp), %rsi
callq 0x11640
movq 0x30(%rsp), %rdi
leaq 0xe5f60(%rip), %rsi     # 0xfa5e6
callq 0x8330
movq %rax, %rdi
leaq 0xe7a64(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe5db7(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x1378bd(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x151e0
testb $0x1, %al
jne 0x146dc
jmp 0x14717
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %edi
movq 0x30(%rsp), %rsi
callq 0x11640
movq 0x30(%rsp), %rdi
leaq 0xe5f01(%rip), %rsi     # 0xfa602
callq 0x8330
movq %rax, %rdi
movq 0x137870(%rip), %rsi    # 0x14bf80
callq 0x8380
jmp 0x1478f
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x150b0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x150e0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x15110
testb $0x1, %al
jne 0x14758
jmp 0x1478d
leaq 0x20(%rsp), %rdi
callq 0x15150
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0x3c(%rsp), %esi
addl $0x1, %esi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x20(%rsp), %rdi
callq 0x15160
jmp 0x14743
jmp 0x1478f
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::FunctionActualParameterList::PrintNode(int, std::ostream&)
void FunctionActualParameterList::PrintNode(int indentation,
                                            std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "FunctionActualParameterList" << LINE_NO << std::endl;
  if (this->arg_list_.empty()) {
    ++indentation;
    PRINT_INDENT;
    outfile << "Empty" << std::endl;
  } else {
    for (const auto &ele : this->arg_list_) {
      ele->PRINT_NODE;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %edi
movq 0x30(%rsp), %rsi
callq 0x11640
movq 0x30(%rsp), %rdi
leaq 0xe5d12(%rip), %rsi     # 0xfa608
callq 0x8330
movq %rax, %rdi
leaq 0xe77f4(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe5b47(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x13764d(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x15370
testb $0x1, %al
jne 0x1494c
jmp 0x14987
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %edi
movq 0x30(%rsp), %rsi
callq 0x11640
movq 0x30(%rsp), %rdi
leaq 0xe5c91(%rip), %rsi     # 0xfa602
callq 0x8330
movq %rax, %rdi
movq 0x137600(%rip), %rsi    # 0x14bf80
callq 0x8380
jmp 0x149ff
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x15240
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x15270
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x152a0
testb $0x1, %al
jne 0x149c8
jmp 0x149fd
leaq 0x20(%rsp), %rdi
callq 0x152e0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0x3c(%rsp), %esi
addl $0x1, %esi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x20(%rsp), %rdi
callq 0x152f0
jmp 0x149b3
jmp 0x149ff
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: luooofan[P]hblzbd_compiler/src/evaluate.cpp
// Function: ast::Identifier::Evaluate(ir::ContextInfo&, std::vector<ir::IR*, std::allocator<ir::IR*>>&)
void Identifier::Evaluate(ir::ContextInfo& ctx, std::vector<ir::IR*>& gIRList) {
  ir::SymbolTableItem* s = nullptr;
  int scope_id = ir::FindSymbol(ctx.scope_id_, name_, s);
  if (!s) {
    ir::SemanticError(line_no_, name_ + ": undefined variable");
  }

  if (!s->is_const_) {
    ir::SemanticError(line_no_, name_ + ": not const type");
  }

  ctx.opn_ = ir::Opn(ir::Opn::Type::Imm, s->initval_[0]);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0x108(%rsp)
movq 0x118(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x3c(%rsp)
movq 0x10(%rax), %rsi
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x81a0
movl 0x3c(%rsp), %edi
movq 0x40(%rsp), %rsi
leaq 0x108(%rsp), %rdx
callq 0x42f30
movl %eax, 0x4c(%rsp)
jmp 0x1e1d8
leaq 0xe0(%rsp), %rdi
callq 0x8728
movl 0x4c(%rsp), %eax
movl %eax, 0x104(%rsp)
cmpq $0x0, 0x108(%rsp)
jne 0x1e293
movq 0x30(%rsp), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x24(%rsp)
movq 0x10(%rax), %rsi
leaq 0xdc756(%rip), %rdx     # 0xfa96c
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xc720
movl 0x24(%rsp), %edi
movq 0x28(%rsp), %rsi
callq 0x47ce0
jmp 0x1e238
leaq 0xb0(%rsp), %rdi
callq 0x8728
jmp 0x1e293
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x8728
jmp 0x1e37f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x8728
jmp 0x1e37f
movq 0x108(%rsp), %rax
testb $0x1, 0x1(%rax)
jne 0x1e30c
movq 0x30(%rsp), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x14(%rsp)
movq 0x10(%rax), %rsi
leaq 0xdc6c9(%rip), %rdx     # 0xfa981
leaq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xc720
movl 0x14(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x47ce0
jmp 0x1e2da
leaq 0x90(%rsp), %rdi
callq 0x8728
jmp 0x1e30c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x8728
jmp 0x1e37f
movq 0x108(%rsp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a60
movl (%rax), %edx
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %esi
callq 0x1f160
movq 0x8(%rsp), %rsi
movq 0x118(%rsp), %rdi
addq $0x8, %rdi
callq 0x433c0
jmp 0x1e34f
leaq 0x50(%rsp), %rdi
callq 0x1f210
addq $0x128, %rsp            # imm = 0x128
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1f210
movq 0xd8(%rsp), %rdi
callq 0x8670
nopl (%rax)
// File: luooofan[P]hblzbd_compiler/src/evaluate.cpp
// Function: ast::UnaryExpression::Evaluate(ir::ContextInfo&, std::vector<ir::IR*, std::allocator<ir::IR*>>&)
void UnaryExpression::Evaluate(ir::ContextInfo& ctx, std::vector<ir::IR*>& gIRList) {
  int r, res;

  rhs_.Evaluate(ctx, gIRList);
  r = ctx.opn_.imm_num_;

  switch (op_) {
    case 258:
      res = r;
      break;
    case 259:
      res = -r;
      break;
    case 260:
      res = !r;
      break;
    default:
      // printf("mystery operator code: %d", op_);
      MyAssert(0);
      break;
  }

  ctx.opn_ = ir::Opn(ir::Opn::Type::Imm, res);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq 0x10(%rsp), %rax
movq 0x78(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0x6c(%rsp)
movl 0xc(%rax), %eax
movl %eax, 0x18(%rsp)
subl $0x102, %eax            # imm = 0x102
je 0x1ea68
jmp 0x1ea4e
movl 0x18(%rsp), %eax
subl $0x103, %eax            # imm = 0x103
je 0x1ea72
jmp 0x1ea5b
movl 0x18(%rsp), %eax
subl $0x104, %eax            # imm = 0x104
je 0x1ea7e
jmp 0x1ea93
movl 0x6c(%rsp), %eax
movl %eax, 0x68(%rsp)
jmp 0x1eaea
xorl %eax, %eax
subl 0x6c(%rsp), %eax
movl %eax, 0x68(%rsp)
jmp 0x1eaea
cmpl $0x0, 0x6c(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x68(%rsp)
jmp 0x1eaea
movq 0x12d54e(%rip), %rdi    # 0x14bfe8
leaq 0xdb657(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0xdbf31(%rip), %rsi     # 0xfa9e1
callq 0x8330
movq %rax, %rdi
leaq 0xdc92b(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x6f, %esi
callq 0x8650
movq %rax, %rdi
movq 0x12d4a5(%rip), %rsi    # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movl 0x68(%rsp), %edx
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %esi
callq 0x1f160
movq 0x8(%rsp), %rsi
movq 0x78(%rsp), %rdi
addq $0x8, %rdi
callq 0x433c0
jmp 0x1eb17
leaq 0x28(%rsp), %rdi
callq 0x1f210
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1f210
movq 0x20(%rsp), %rdi
callq 0x8670
nopl (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/generate_ir.cpp
// Function: ast::BreakStatement::GenerateIR(ir::ContextInfo&, std::vector<ir::IR*, std::allocator<ir::IR*>>&)
void BreakStatement::GenerateIR(ir::ContextInfo &ctx, std::vector<ir::IR *> &gIRList) {
  // 检查是否在while循环中
  if (ctx.break_label_.empty()) {
    ir::SemanticError(this->line_no_, "'break' not in while loop");
  } else {
    // genir (goto,breaklabel,-,-)
    gIRList.push_back(new ir::IR(IROpKind::GOTO, {OpnType::Label, ctx.break_label_.top()}));
  }
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xe8(%rsp), %rdi
addq $0xa8, %rdi
callq 0x374f0
testb $0x1, %al
jne 0x29ff9
jmp 0x2a0ad
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
leaq 0xbf(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x8680
movq 0x28(%rsp), %rdx
leaq 0xd0c10(%rip), %rsi     # 0xfac33
leaq 0xc0(%rsp), %rdi
callq 0xc570
jmp 0x2a032
movl 0x24(%rsp), %edi
leaq 0xc0(%rsp), %rsi
callq 0x47ce0
jmp 0x2a045
leaq 0xc0(%rsp), %rdi
callq 0x8728
leaq 0xbf(%rsp), %rdi
callq 0x83c0
jmp 0x2a1d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x2a09b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x8728
leaq 0xbf(%rsp), %rdi
callq 0x83c0
jmp 0x2a1d8
movq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xe0, %edi
callq 0x8340
movq %rax, 0x10(%rsp)
movb $0x1, 0x3f(%rsp)
movq 0xe8(%rsp), %rdi
addq $0xa8, %rdi
callq 0x37510
movq %rax, 0x18(%rsp)
jmp 0x2a0e9
movq 0x18(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x81a0
jmp 0x2a0fa
leaq 0x60(%rsp), %rdi
movl $0x2, %esi
leaq 0x40(%rsp), %rdx
callq 0x36d70
jmp 0x2a110
movq 0x10(%rsp), %rdi
movl $0xb, %esi
leaq 0x60(%rsp), %rdx
callq 0x36c00
jmp 0x2a126
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movb $0x0, 0x3f(%rsp)
movq %rax, 0xa0(%rsp)
leaq 0xa0(%rsp), %rsi
callq 0x185b0
jmp 0x2a14c
leaq 0x60(%rsp), %rdi
callq 0x1f210
leaq 0x40(%rsp), %rdi
callq 0x8728
jmp 0x2a1d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x2a1b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x2a1ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x1f210
leaq 0x40(%rsp), %rdi
callq 0x8728
testb $0x1, 0x3f(%rsp)
jne 0x2a1bf
jmp 0x2a1ce
movq 0x10(%rsp), %rdi
movl $0xe0, %esi
callq 0x8350
jmp 0x2a1d8
addq $0xf8, %rsp
retq
movq 0xb0(%rsp), %rdi
callq 0x8670
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/generate_ir.cpp
// Function: ast::ContinueStatement::GenerateIR(ir::ContextInfo&, std::vector<ir::IR*, std::allocator<ir::IR*>>&)
void ContinueStatement::GenerateIR(ir::ContextInfo &ctx, std::vector<ir::IR *> &gIRList) {
  // 检查是否在while循环中
  if (ctx.continue_label_.empty()) {
    ir::SemanticError(this->line_no_, "'continue' not in while loop");
  } else {
    // genir (goto,continuelabel,-,-)
    gIRList.push_back(new ir::IR(IROpKind::GOTO, {OpnType::Label, ctx.continue_label_.top()}));
  }
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xe8(%rsp), %rdi
addq $0xf8, %rdi
callq 0x374f0
testb $0x1, %al
jne 0x2a239
jmp 0x2a2ed
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
leaq 0xbf(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x8680
movq 0x28(%rsp), %rdx
leaq 0xd09ea(%rip), %rsi     # 0xfac4d
leaq 0xc0(%rsp), %rdi
callq 0xc570
jmp 0x2a272
movl 0x24(%rsp), %edi
leaq 0xc0(%rsp), %rsi
callq 0x47ce0
jmp 0x2a285
leaq 0xc0(%rsp), %rdi
callq 0x8728
leaq 0xbf(%rsp), %rdi
callq 0x83c0
jmp 0x2a410
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x2a2db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x8728
leaq 0xbf(%rsp), %rdi
callq 0x83c0
jmp 0x2a418
movq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xe0, %edi
callq 0x8340
movq %rax, 0x10(%rsp)
movb $0x1, 0x3f(%rsp)
movq 0xe8(%rsp), %rdi
addq $0xf8, %rdi
callq 0x37510
movq %rax, 0x18(%rsp)
jmp 0x2a329
movq 0x18(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x81a0
jmp 0x2a33a
leaq 0x60(%rsp), %rdi
movl $0x2, %esi
leaq 0x40(%rsp), %rdx
callq 0x36d70
jmp 0x2a350
movq 0x10(%rsp), %rdi
movl $0xb, %esi
leaq 0x60(%rsp), %rdx
callq 0x36c00
jmp 0x2a366
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movb $0x0, 0x3f(%rsp)
movq %rax, 0xa0(%rsp)
leaq 0xa0(%rsp), %rsi
callq 0x185b0
jmp 0x2a38c
leaq 0x60(%rsp), %rdi
callq 0x1f210
leaq 0x40(%rsp), %rdi
callq 0x8728
jmp 0x2a410
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x2a3f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x2a3ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x1f210
leaq 0x40(%rsp), %rdi
callq 0x8728
testb $0x1, 0x3f(%rsp)
jne 0x2a3ff
jmp 0x2a40e
movq 0x10(%rsp), %rdi
movl $0xe0, %esi
callq 0x8350
jmp 0x2a418
addq $0xf8, %rsp
retq
movq 0xb0(%rsp), %rdi
callq 0x8670
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/generate_ir.cpp
// Function: ast::Block::GenerateIR(ir::ContextInfo&, std::vector<ir::IR*, std::allocator<ir::IR*>>&)
void Block::GenerateIR(ir::ContextInfo &ctx, std::vector<ir::IR *> &gIRList) {
  int parent_scope_id = ctx.scope_id_;
  if (!ctx.has_aug_scope) {
    // new scope
    ctx.scope_id_ = ir::gScopes.size();
    ir::gScopes.push_back({ctx.scope_id_, parent_scope_id});
  }
  ctx.has_aug_scope = false;
  for (const auto &stmt : this->statement_list_) {
    stmt->GenerateIR(ctx, gIRList);
  }
  // src scope
  ctx.scope_id_ = parent_scope_id;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8c(%rsp)
movq 0x98(%rsp), %rax
testb $0x1, 0x208(%rax)
jne 0x2a9d3
leaq 0x121cc3(%rip), %rdi    # 0x14c628
movq %rdi, (%rsp)
callq 0x37290
movl %eax, %ecx
movq 0x98(%rsp), %rax
movl %ecx, (%rax)
movq 0x98(%rsp), %rax
movl (%rax), %esi
movl 0x8c(%rsp), %edx
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x360d0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x360a0
jmp 0x2a9aa
leaq 0x48(%rsp), %rdi
callq 0x36110
jmp 0x2a9d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x36110
jmp 0x2aa75
movq 0x10(%rsp), %rax
movq 0x98(%rsp), %rcx
movb $0x0, 0x208(%rcx)
addq $0x10, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x14cf0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x14d20
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x14d50
testb $0x1, %al
jne 0x2aa23
jmp 0x2aa5c
leaq 0x28(%rsp), %rdi
callq 0x14d90
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
callq 0x14da0
jmp 0x2aa0e
movl 0x8c(%rsp), %ecx
movq 0x98(%rsp), %rax
movl %ecx, (%rax)
addq $0xa8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x8670
nop
// File: luooofan[P]hblzbd_compiler/src/ir.cpp
// Function: ir::Scope::Print(std::ostream&)
void Scope::Print(std::ostream &outfile) {
  outfile << "Scope:" << std::endl
          << "  scope_id: " << this->scope_id_ << "  parent_scope_id: " << this->parent_scope_id_ << std::endl;
  if (!this->symbol_table_.empty()) {
    outfile << std::setw(10) << "name" << std::setw(10) << "is_array" << std::setw(10) << "is_const" << std::endl;
  }
  for (auto &symbol : this->symbol_table_) {
    outfile << std::setw(10) << symbol.first;
    symbol.second.Print(outfile);
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rdi
leaq 0xb895e(%rip), %rsi     # 0xfb1c2
callq 0x8330
movq %rax, %rdi
movq 0x10970d(%rip), %rsi    # 0x14bf80
callq 0x8380
movq %rax, %rdi
leaq 0xb8947(%rip), %rsi     # 0xfb1c9
callq 0x8330
movq %rax, %rdi
movq 0x28(%rsp), %rax
movl 0x38(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xb8935(%rip), %rsi     # 0xfb1d6
callq 0x8330
movq %rax, %rdi
movq 0x28(%rsp), %rax
movl 0x3c(%rax), %esi
callq 0x8650
movq %rax, %rdi
movq 0x1096c0(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x28(%rsp), %rdi
callq 0x10980
testb $0x1, %al
jne 0x4297b
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0xa, %edi
callq 0x47e80
movq 0x10(%rsp), %rdi
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %esi
callq 0x8420
movq %rax, %rdi
leaq 0xb8890(%rip), %rsi     # 0xfb197
callq 0x8330
movq %rax, 0x18(%rsp)
movl $0xa, %edi
callq 0x47e80
movq 0x18(%rsp), %rdi
movl %eax, 0x60(%rsp)
movl 0x60(%rsp), %esi
callq 0x8420
movq %rax, %rdi
leaq 0xb88b3(%rip), %rsi     # 0xfb1ea
callq 0x8330
movq %rax, 0x20(%rsp)
movl $0xa, %edi
callq 0x47e80
movq 0x20(%rsp), %rdi
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %esi
callq 0x8420
movq %rax, %rdi
leaq 0xb888c(%rip), %rsi     # 0xfb1f3
callq 0x8330
movq %rax, %rdi
movq 0x10960a(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x109a0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x109d0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x10a00
testb $0x1, %al
jne 0x429b8
jmp 0x42a19
leaq 0x48(%rsp), %rdi
callq 0x10a20
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xa, %edi
callq 0x47e80
movq 0x8(%rsp), %rdi
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %esi
callq 0x8420
movq %rax, %rdi
movq 0x38(%rsp), %rsi
callq 0x8310
movq 0x38(%rsp), %rdi
addq $0x20, %rdi
movq 0x68(%rsp), %rsi
callq 0x42cb0
leaq 0x48(%rsp), %rdi
callq 0x10ad0
jmp 0x429a3
addq $0x78, %rsp
retq
nop
// File: luooofan[P]hblzbd_compiler/src/ir.cpp
// Function: ir::PrintFuncTable(std::ostream&)
void PrintFuncTable(std::ostream &outfile) {
  outfile << "FuncTable:" << std::endl;
  outfile << std::setw(10) << "name" << std::setw(10) << "ret_type" << std::setw(10) << "size" << std::setw(10)
          << "scope_id" << std::endl;
  for (auto &symbol : gFuncTable) {
    outfile << std::setw(10) << symbol.first;
    symbol.second.Print(outfile);
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
leaq 0xb8757(%rip), %rsi     # 0xfb18c
callq 0x8330
movq %rax, %rdi
movq 0x10953c(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xa, %edi
callq 0x47e80
movq 0x8(%rsp), %rdi
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %esi
callq 0x8420
movq %rax, %rdi
leaq 0xb871e(%rip), %rsi     # 0xfb197
callq 0x8330
movq %rax, 0x10(%rsp)
movl $0xa, %edi
callq 0x47e80
movq 0x10(%rsp), %rdi
movl %eax, 0x58(%rsp)
movl 0x58(%rsp), %esi
callq 0x8420
movq %rax, %rdi
leaq 0xb86f3(%rip), %rsi     # 0xfb19c
callq 0x8330
movq %rax, 0x18(%rsp)
movl $0xa, %edi
callq 0x47e80
movq 0x18(%rsp), %rdi
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %esi
callq 0x8420
movq %rax, %rdi
leaq 0xb86cc(%rip), %rsi     # 0xfb1a5
callq 0x8330
movq %rax, 0x20(%rsp)
movl $0xa, %edi
callq 0x47e80
movq 0x20(%rsp), %rdi
movl %eax, 0x50(%rsp)
movl 0x50(%rsp), %esi
callq 0x8420
movq %rax, %rdi
leaq 0xb86a1(%rip), %rsi     # 0xfb1aa
callq 0x8330
movq %rax, %rdi
movq 0x109468(%rip), %rsi    # 0x14bf80
callq 0x8380
leaq 0x109b1c(%rip), %rax    # 0x14c640
movq %rax, 0x48(%rsp)
leaq 0x109b10(%rip), %rdi    # 0x14c640
callq 0x47ea0
movq %rax, 0x40(%rsp)
leaq 0x109aff(%rip), %rdi    # 0x14c640
callq 0x36170
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x47ed0
testb $0x1, %al
jne 0x42b60
jmp 0x42bbf
leaq 0x40(%rsp), %rdi
callq 0x186b0
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movl $0xa, %edi
callq 0x47e80
movq (%rsp), %rdi
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %esi
callq 0x8420
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x8310
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
movq 0x60(%rsp), %rsi
callq 0x42bd0
leaq 0x40(%rsp), %rdi
callq 0x47ef0
jmp 0x42b4b
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ir.cpp
// Function: ir::SymbolTableItem::Print(std::ostream&)
void SymbolTableItem::Print(std::ostream &outfile) {
  outfile << std::setw(10) << (this->is_array_ ? "√" : "×") << std::setw(10) << (this->is_const_ ? "√" : "×");
  if (this->is_array_) {
    outfile << std::setw(10) << "shape: ";
    for (const auto &shape : this->shape_) {
      outfile << "[" << shape << "]";
    }
  }
  if (!this->initval_.empty()) {
  }
  outfile << std::endl;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0xa, %edi
callq 0x47e80
movq 0x10(%rsp), %rdi
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %esi
callq 0x8420
movq %rax, %rdi
movq 0x20(%rsp), %rax
movb (%rax), %cl
leaq 0xb84b8(%rip), %rsi     # 0xfb1b7
leaq 0xb84ad(%rip), %rax     # 0xfb1b3
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x8330
movq %rax, 0x18(%rsp)
movl $0xa, %edi
callq 0x47e80
movq 0x18(%rsp), %rdi
movl %eax, 0x50(%rsp)
movl 0x50(%rsp), %esi
callq 0x8420
movq %rax, %rdi
movq 0x20(%rsp), %rax
movb 0x1(%rax), %cl
leaq 0xb8472(%rip), %rsi     # 0xfb1b7
leaq 0xb8467(%rip), %rax     # 0xfb1b3
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x8330
movq 0x20(%rsp), %rax
testb $0x1, (%rax)
je 0x42e28
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xa, %edi
callq 0x47e80
movq 0x8(%rsp), %rdi
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %esi
callq 0x8420
movq %rax, %rdi
leaq 0xb8424(%rip), %rsi     # 0xfb1ba
callq 0x8330
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1fc30
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1f470
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x37210
testb $0x1, %al
jne 0x42ddc
jmp 0x42e26
leaq 0x38(%rsp), %rdi
callq 0x37250
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
leaq 0xb7372(%rip), %rsi     # 0xfa169
callq 0x8330
movq %rax, %rdi
movq 0x28(%rsp), %rax
movl (%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xb8443(%rip), %rsi     # 0xfb258
callq 0x8330
leaq 0x38(%rsp), %rdi
callq 0x37260
jmp 0x42dc7
jmp 0x42e28
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
callq 0x10a80
testb $0x1, %al
jne 0x42e3c
jmp 0x42e3c
movq 0x58(%rsp), %rdi
movq 0x109138(%rip), %rsi    # 0x14bf80
callq 0x8380
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ir.cpp
// Function: ir::Scope::IsSubScope(int)
bool Scope::IsSubScope(int scope_id) {
  MyAssert(scope_id >= 0);
  // <0无意义
  int sid = this->scope_id_;
  while (-1 != sid) {
    if (sid == scope_id) {
      return true;
    } else {
      sid = gScopes[sid].parent_scope_id_;
    }
  }
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x42ed5
movq 0x109163(%rip), %rdi    # 0x14bfe8
leaq 0xb726c(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0xb8361(%rip), %rsi     # 0xfb1fc
callq 0x8330
movq %rax, %rdi
leaq 0xb8540(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x46, %esi
callq 0x8650
movq %rax, %rdi
movq 0x1090ba(%rip), %rsi    # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movq 0x8(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x10(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x10(%rsp), %eax
je 0x42f17
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jne 0x42efd
movb $0x1, 0x27(%rsp)
jmp 0x42f1c
movslq 0x10(%rsp), %rsi
leaq 0x10971f(%rip), %rdi    # 0x14c628
callq 0x183c0
movl 0x3c(%rax), %eax
movl %eax, 0x10(%rsp)
jmp 0x42ee1
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ir.cpp
// Function: ir::FindSymbol(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ir::SymbolTableItem*&)
int FindSymbol(int scope_id, std::string name, SymbolTableItem *&res_symbol_item) {
  while (-1 != scope_id) {
    auto &current_scope = gScopes[scope_id];
    auto &current_symbol_table = current_scope.symbol_table_;
    auto symbol_iter = current_symbol_table.find(name);
    if (symbol_iter == current_symbol_table.end()) {
      scope_id = current_scope.parent_scope_id_;
    } else {
      res_symbol_item = &((*symbol_iter).second);
      return scope_id;
    }
  }
  res_symbol_item = nullptr;
  return -1;
}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movl %edi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x40(%rsp), %eax
je 0x42fe4
movslq 0x40(%rsp), %rsi
leaq 0x1096c6(%rip), %rdi    # 0x14c628
callq 0x183c0
movq 0x8(%rsp), %rsi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1f270
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x109d0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x36e80
testb $0x1, %al
jne 0x42fae
jmp 0x42fbc
movq 0x28(%rsp), %rax
movl 0x3c(%rax), %eax
movl %eax, 0x40(%rsp)
jmp 0x42fdf
leaq 0x18(%rsp), %rdi
callq 0x10a20
movq %rax, %rcx
addq $0x20, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movl 0x40(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x42ff8
jmp 0x42f47
movq 0x30(%rsp), %rax
movq $0x0, (%rax)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ir.cpp
// Function: ir::Opn::operator=(ir::Opn const&)
Opn &Opn::operator=(const Opn &opn) {
  type_ = opn.type_, imm_num_ = opn.imm_num_, scope_id_ = opn.scope_id_, ssa_id_ = opn.ssa_id_;
  name_ = opn.name_;
  if (nullptr != offset_) {
    delete offset_;
    offset_ = nullptr;
  }
  if (nullptr != opn.offset_) offset_ = new Opn(*opn.offset_);
  return *this;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq 0x28(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x28(%rdi)
movq 0x28(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x38(%rdi)
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x8050
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x30(%rcx), %rax
je 0x432cb
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x432be
movq 0x8(%rsp), %rdi
callq 0x1f210
movq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x8350
movq 0x10(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x28(%rsp), %rcx
xorl %eax, %eax
cmpq 0x30(%rcx), %rax
je 0x43329
movl $0x40, %edi
callq 0x8340
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rsi
callq 0x43130
jmp 0x432fc
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x30(%rax)
jmp 0x43329
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x40, %esi
callq 0x8350
jmp 0x43333
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x8670
nopl (%rax)
// File: luooofan[P]hblzbd_compiler/src/ir.cpp
// Function: ir::Opn::operator=(ir::Opn&&)
Opn &Opn::operator=(Opn &&opn) {
  type_ = opn.type_, imm_num_ = opn.imm_num_, scope_id_ = opn.scope_id_, ssa_id_ = opn.ssa_id_;
  if (nullptr != offset_) {
    delete offset_;
    offset_ = nullptr;
  }
  offset_ = opn.offset_;
  name_ = std::move(opn.name_);
  return *this;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rcx)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rcx)
movq 0x18(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x28(%rcx)
movq 0x18(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x38(%rcx)
xorl %eax, %eax
cmpq 0x30(%rcx), %rax
je 0x43444
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x43437
movq 0x8(%rsp), %rdi
callq 0x1f210
movq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x8350
movq 0x10(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x30(%rdi)
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x8480
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ir.cpp
// Function: ir::GetOpKind(int, bool)
IR::OpKind GetOpKind(int op, bool reverse) {
  if (reverse) {
    switch (op) {
      case EQ:
        return IR::OpKind::JNE;
      case NE:
        return IR::OpKind::JEQ;
      case LT:
        return IR::OpKind::JGE;
      case LE:
        return IR::OpKind::JGT;
      case GT:
        return IR::OpKind::JLE;
      case GE:
        return IR::OpKind::JLT;
      default:
        return IR::OpKind::VOID;
    }
  } else {
    switch (op) {
      case EQ:
        return IR::OpKind::JEQ;
      case NE:
        return IR::OpKind::JNE;
      case LT:
        return IR::OpKind::JLT;
      case LE:
        return IR::OpKind::JLE;
      case GT:
        return IR::OpKind::JGT;
      case GE:
        return IR::OpKind::JGE;
      default:
        return IR::OpKind::VOID;
    }
  }
  return IR::OpKind::VOID;
}

// Assembly:
movb %sil, %al
movl %edi, -0x8(%rsp)
andb $0x1, %al
movb %al, -0x9(%rsp)
testb $0x1, -0x9(%rsp)
je 0x43513
movl -0x8(%rsp), %eax
addl $0xfffffef8, %eax       # imm = 0xFFFFFEF8
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0x5, %eax
ja 0x43509
movq -0x18(%rsp), %rax
leaq 0xb7c5b(%rip), %rcx     # 0xfb110
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xe, -0x4(%rsp)
jmp 0x43581
movl $0xd, -0x4(%rsp)
jmp 0x43581
movl $0x12, -0x4(%rsp)
jmp 0x43581
movl $0x11, -0x4(%rsp)
jmp 0x43581
movl $0x10, -0x4(%rsp)
jmp 0x43581
movl $0xf, -0x4(%rsp)
jmp 0x43581
movl $0x13, -0x4(%rsp)
jmp 0x43581
movl -0x8(%rsp), %eax
addl $0xfffffef8, %eax       # imm = 0xFFFFFEF8
movl %eax, %ecx
movq %rcx, -0x20(%rsp)
subl $0x5, %eax
ja 0x43579
movq -0x20(%rsp), %rax
leaq 0xb7bc4(%rip), %rcx     # 0xfb0f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xd, -0x4(%rsp)
jmp 0x43581
movl $0xe, -0x4(%rsp)
jmp 0x43581
movl $0xf, -0x4(%rsp)
jmp 0x43581
movl $0x10, -0x4(%rsp)
jmp 0x43581
movl $0x11, -0x4(%rsp)
jmp 0x43581
movl $0x12, -0x4(%rsp)
jmp 0x43581
movl $0x13, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ir_struct.cpp
// Function: IRModule::EmitCode(std::ostream&)
void IRModule::EmitCode(std::ostream& out) {
  out << "@ module: " << this->name_ << std::endl;
  // this->global_scope_.Print(out);
  for (auto func : this->func_list_) {
    func->EmitCode(out);
    out << std::endl;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
leaq 0xb182c(%rip), %rsi     # 0xfa2df
callq 0x8330
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x8310
movq %rax, %rdi
movq 0x1034ae(%rip), %rsi    # 0x14bf80
callq 0x8380
movq (%rsp), %rax
addq $0x28, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1d3c0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1d240
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x49210
testb $0x1, %al
jne 0x48b17
jmp 0x48b55
leaq 0x18(%rsp), %rdi
callq 0x49250
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x48b60
movq 0x28(%rsp), %rdi
movq 0x10343c(%rip), %rsi    # 0x14bf80
callq 0x8380
leaq 0x18(%rsp), %rdi
callq 0x49260
jmp 0x48b02
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ir_struct.cpp
// Function: IRFunction::EmitCode(std::ostream&)
void IRFunction::EmitCode(std::ostream& out) {
  out << "@ Function: " << this->name_ << std::endl;
#ifdef GENIR_WITH_COMMENT
  out << "@ call_func: ";
  for (auto func : this->call_func_list_) {
    out << func->name_ << " ";
  }
  out << std::endl;
#endif
  out << "@ Function Begin:" << std::endl;
  out << std::endl;
  for (auto bb : this->bb_list_) {
    bb->EmitCode(out);
    out << std::endl;
  }
  out << "@ Function End." << std::endl;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
leaq 0xb2725(%rip), %rsi     # 0xfb2a8
callq 0x8330
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x8310
movq %rax, %rdi
movq 0x1033de(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x28(%rsp), %rdi
leaq 0xb1845(%rip), %rsi     # 0xfa3f8
callq 0x8330
movq %rax, %rdi
movq 0x1033be(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x28(%rsp), %rdi
movq 0x1033ad(%rip), %rsi    # 0x14bf80
callq 0x8380
movq (%rsp), %rax
addq $0x30, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1cc40
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1cac0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x492e0
testb $0x1, %al
jne 0x48c18
jmp 0x48c56
leaq 0x18(%rsp), %rdi
callq 0x49320
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x48d90
movq 0x28(%rsp), %rdi
movq 0x10333b(%rip), %rsi    # 0x14bf80
callq 0x8380
leaq 0x18(%rsp), %rdi
callq 0x49330
jmp 0x48c03
movq 0x28(%rsp), %rdi
leaq 0xb17a8(%rip), %rsi     # 0xfa40a
callq 0x8330
movq %rax, %rdi
movq 0x10330f(%rip), %rsi    # 0x14bf80
callq 0x8380
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ir_struct.cpp
// Function: IRBasicBlock::IsByDom(IRBasicBlock*)
bool IRBasicBlock::IsByDom(IRBasicBlock* bb) {
  auto n = this;
  while (nullptr != n) {
    if (bb == n) return true;
    n = n->idom_;
  }
  return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
xorl %eax, %eax
cmpq -0x20(%rsp), %rax
je 0x491f3
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jne 0x491e0
movb $0x1, -0x1(%rsp)
jmp 0x491f8
movq -0x20(%rsp), %rax
movq 0x250(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x491c4
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: luooofan[P]hblzbd_compiler/src/../include/Pass/pass_manager.h
// Function: void PassManager::AddPass<SimplifyCFG>(bool)
void AddPass(bool emit = false) {
    try {
      Pass* pass = new PassTy(m_);
      pass->SetName(typeid(PassTy).name());
      pass->SetEmit(emit);
      passes_.push_back(pass);
    } catch (...) {
      std::cerr << "ERROR class type:" << typeid(PassTy).name() << " be passed to AddPass();" << std::endl;
      exit(255);
    }
  }

// Assembly:
subq $0x98, %rsp
movb %sil, %al
movq %rdi, 0x90(%rsp)
andb $0x1, %al
movb %al, 0x8f(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x38, %edi
callq 0x8340
movq %rax, 0x40(%rsp)
jmp 0x4c1f9
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x4f0e0
jmp 0x4c20e
movq 0x40(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xffae1(%rip), %rdi     # 0x14bd10
callq 0x4f150
movq %rax, 0x28(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x8680
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0xc570
jmp 0x4c25e
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x4f120
jmp 0x4c26f
leaq 0x50(%rsp), %rdi
callq 0x8728
leaq 0x4f(%rsp), %rdi
callq 0x83c0
movq 0x80(%rsp), %rdi
movzbl 0x8f(%rsp), %esi
andl $0x1, %esi
callq 0x4f1a0
jmp 0x4c29d
movq 0x38(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x4f1c0
jmp 0x4c2b1
jmp 0x4c3a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x4c317
movq 0x40(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
movl $0x38, %esi
callq 0x8350
jmp 0x4c317
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x4c30d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x8728
leaq 0x4f(%rsp), %rdi
callq 0x83c0
movq 0x78(%rsp), %rdi
callq 0x8180
movq 0xffcc0(%rip), %rdi     # 0x14bfe8
leaq 0xaf182(%rip), %rsi     # 0xfb4b1
callq 0x8330
movq %rax, 0x18(%rsp)
jmp 0x4c33b
leaq 0xff9ce(%rip), %rdi     # 0x14bd10
callq 0x4f150
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x8330
movq %rax, 0x10(%rsp)
jmp 0x4c35b
movq 0x10(%rsp), %rdi
leaq 0xaf15c(%rip), %rsi     # 0xfb4c3
callq 0x8330
movq %rax, 0x8(%rsp)
jmp 0x4c373
movq 0x8(%rsp), %rdi
movq 0xffc01(%rip), %rsi     # 0x14bf80
callq 0x8380
jmp 0x4c386
movl $0xff, %edi
callq 0x8460
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0x8600
jmp 0x4c3a5
jmp 0x4c3af
addq $0x98, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x8670
movq %rax, %rdi
callq 0xdd40
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/../include/Pass/pass_manager.h
// Function: PassManager::Run(bool, std::ostream&)
void Run(bool emit = false, std::ostream& out = std::cout) {
    int i = 1;
    for (auto pass : this->passes_) {
#ifdef DEBUG_PASSES_PROCESS
      std::cout << ">>>>>>>>>>>> Start pass " << pass->GetName() << " <<<<<<<<<<<<" << std::endl;
#endif
      pass->Run();

      if (emit || pass->IsEmit()) {
        out << ">>>>>>>>>>>> After pass " << pass->GetName() << " <<<<<<<<<<<<" << std::endl;
        (*m_)->EmitCode(out);
      }
    }
  }

// Assembly:
subq $0xd8, %rsp
movb %sil, %al
movq %rdi, 0xd0(%rsp)
andb $0x1, %al
movb %al, 0xcf(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x1, 0xbc(%rsp)
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x4edb0
movq %rax, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x4ede0
movq %rax, 0xa0(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x4ee10
testb $0x1, %al
jne 0x4e25b
jmp 0x4e3f7
leaq 0xa8(%rsp), %rdi
callq 0x4ee50
movq (%rax), %rax
movq %rax, 0x98(%rsp)
movq 0xfdd36(%rip), %rdi     # 0x14bfb0
leaq 0xad1f0(%rip), %rsi     # 0xfb471
callq 0x8330
movq %rax, 0x28(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x4ee60
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x8310
movq %rax, 0x38(%rsp)
jmp 0x4e2b8
movq 0x38(%rsp), %rdi
leaq 0xad1c6(%rip), %rsi     # 0xfb48a
callq 0x8330
movq %rax, 0x20(%rsp)
jmp 0x4e2d0
movq 0x20(%rsp), %rdi
movq 0xfdca4(%rip), %rsi     # 0x14bf80
callq 0x8380
jmp 0x4e2e3
leaq 0x78(%rsp), %rdi
callq 0x8728
movq 0x98(%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
testb $0x1, 0xcf(%rsp)
jne 0x4e31a
movq 0x98(%rsp), %rdi
callq 0x4ee90
testb $0x1, %al
jne 0x4e31a
jmp 0x4e3e3
movq 0xc0(%rsp), %rdi
leaq 0xad16f(%rip), %rsi     # 0xfb498
callq 0x8330
movq %rax, 0x8(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4ee60
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8310
movq %rax, 0x18(%rsp)
jmp 0x4e360
movq 0x18(%rsp), %rdi
leaq 0xad11e(%rip), %rsi     # 0xfb48a
callq 0x8330
movq %rax, (%rsp)
jmp 0x4e377
movq (%rsp), %rdi
movq 0xfdbfe(%rip), %rsi     # 0x14bf80
callq 0x8380
jmp 0x4e389
leaq 0x48(%rsp), %rdi
callq 0x8728
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq 0xc0(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x4e3e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x8728
jmp 0x4e3ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x8728
jmp 0x4e3ff
jmp 0x4e3e5
leaq 0xa8(%rsp), %rdi
callq 0x4eea0
jmp 0x4e23d
addq $0xd8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x8670
nopl (%rax)
// File: luooofan[P]hblzbd_compiler/src/scanner.cpp
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 179 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 178);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq 0xf179d(%rip), %rax     # 0x14c748
movq %rax, -0x10(%rsp)
movb $0x1, -0x11(%rsp)
movslq -0x4(%rsp), %rcx
leaq 0xa16df(%rip), %rax     # 0xfc6a0
cmpw $0x0, (%rax,%rcx,2)
je 0x5afde
movl -0x4(%rsp), %eax
movl %eax, 0xf1782(%rip)     # 0x14c754
movq -0x10(%rsp), %rax
movq %rax, 0xf177a(%rip)     # 0x14c758
jmp 0x5afe0
movslq -0x4(%rsp), %rcx
leaq 0xa1b54(%rip), %rax     # 0xfcb40
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rsp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0xa180f(%rip), %rax     # 0xfc810
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rsp), %eax
je 0x5b040
movslq -0x4(%rsp), %rcx
leaq 0xa1cc9(%rip), %rax     # 0xfcce0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rsp)
cmpl $0xb3, -0x4(%rsp)
jl 0x5b03e
movzbl -0x11(%rsp), %eax
movl %eax, %ecx
leaq 0xa1e49(%rip), %rax     # 0xfce80
movb (%rax,%rcx), %al
movb %al, -0x11(%rsp)
jmp 0x5afe0
movslq -0x4(%rsp), %rcx
leaq 0xa1af4(%rip), %rax     # 0xfcb40
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rsp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0xa1e5f(%rip), %rax     # 0xfcec0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rsp)
cmpl $0xb2, -0x4(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rsp)
cmpl $0x0, -0x8(%rsp)
je 0x5b08c
xorl %eax, %eax
movl %eax, -0x18(%rsp)
jmp 0x5b094
movl -0x4(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
retq
nopl (%rax)
// File: luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: Value::KillUse(Value*)
void Value::KillUse(Value *val) {
  for (auto it = use_list_.begin(); it != use_list_.end();) {
    if (val == (*it)->Get()) {
      it = use_list_.erase(it);
    } else {
      ++it;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x10, %rdi
callq 0x5e160
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x5e1b0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5e190
testb $0x1, %al
jne 0x5c14e
jmp 0x5c1c1
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5e1e0
movq (%rax), %rdi
callq 0x5e200
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jne 0x5c1b2
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5e260
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5e210
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x5c1bc
leaq 0x30(%rsp), %rdi
callq 0x5e280
jmp 0x5c126
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: Value::KillUse(SSAFunction*)
void Value::KillUse(SSAFunction *func) {
  // 删除该值在该函数中的全部使用
  for (auto it = use_list_.begin(); it != use_list_.end();) {
    auto inst = dynamic_cast<SSAInstruction *>((*it)->Get());
    if (nullptr != inst && inst->GetParent()->GetFunction() == func) {
      it = use_list_.erase(it);
    } else {
      ++it;
    }
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x10, %rdi
callq 0x5e160
movq %rax, 0x40(%rsp)
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
callq 0x5e1b0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5e190
testb $0x1, %al
jne 0x5c261
jmp 0x5c320
leaq 0x40(%rsp), %rdi
callq 0x5e1e0
movq (%rax), %rdi
callq 0x5e200
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x5c2a1
movq 0x10(%rsp), %rdi
leaq 0xef246(%rip), %rsi     # 0x14b4d0
leaq 0xef187(%rip), %rdx     # 0x14b418
xorl %eax, %eax
movl %eax, %ecx
callq 0x8410
movq %rax, 0x8(%rsp)
jmp 0x5c2aa
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x5c2aa
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
xorl %eax, %eax
cmpq 0x30(%rsp), %rax
je 0x5c311
movq 0x30(%rsp), %rdi
callq 0x5e2b0
movq %rax, %rdi
callq 0x5e2c0
cmpq 0x48(%rsp), %rax
jne 0x5c311
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5e260
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5e210
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x5c31b
leaq 0x40(%rsp), %rdi
callq 0x5e280
jmp 0x5c236
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)