LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: hdlguy[P]fft_demo/fft.cpp
// Function: Fft::convolve(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>&)
void Fft::convolve(const vector<double> &x, const vector<double> &y, vector<double> &out) {
	if (x.size() != y.size() || x.size() != out.size())
		throw "Mismatched lengths";
	size_t n = x.size();
	vector<double> ximag(n), yimag(n), zimag(n);
	convolve(x, ximag, y, yimag, out, zimag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2e00
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e00
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jne 0x2c47
movq -0x8(%rbp), %rdi
callq 0x2e00
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2e00
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
je 0x2c6e
movl $0x8, %edi
callq 0x10a0
movq %rax, %rdi
leaq 0x33e5(%rip), %rax      # 0x6040
movq %rax, (%rdi)
movq 0x6363(%rip), %rsi      # 0x8fc8
xorl %eax, %eax
movl %eax, %edx
callq 0x1170
movq -0x8(%rbp), %rdi
callq 0x2e00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x2e20
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x2e40
jmp 0x2caf
leaq -0x39(%rbp), %rdi
callq 0x2eb0
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x2e20
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x2e40
jmp 0x2cec
leaq -0x69(%rbp), %rdi
callq 0x2eb0
movq -0x20(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x2e20
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x2e40
jmp 0x2d2f
leaq -0x89(%rbp), %rdi
callq 0x2eb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %r8
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rcx
leaq -0x88(%rbp), %r9
callq 0x26d0
jmp 0x2d5d
leaq -0x88(%rbp), %rdi
callq 0x2ef0
leaq -0x68(%rbp), %rdi
callq 0x2ef0
leaq -0x38(%rbp), %rdi
callq 0x2ef0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x2eb0
jmp 0x2df6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x2eb0
jmp 0x2ded
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x89(%rbp), %rdi
callq 0x2eb0
jmp 0x2de4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2ef0
leaq -0x68(%rbp), %rdi
callq 0x2ef0
leaq -0x38(%rbp), %rdi
callq 0x2ef0
movq -0x48(%rbp), %rdi
callq 0x11a0
nop
// File: luooofan[P]hblzbd_compiler/src/arm.cpp
// Function: arm::GetOppositeCond(arm::Cond)
Cond GetOppositeCond(Cond cond) {
  switch (cond) {
    case Cond::AL:
      return Cond::AL;
    case Cond::EQ:
      return Cond::NE;
    case Cond::NE:
      return Cond::EQ;
    case Cond::GT:
      return Cond::LE;
    case Cond::GE:
      return Cond::LT;
    case Cond::LT:
      return Cond::GE;
    case Cond::LE:
      return Cond::GT;
    default:
      MyAssert(0);
      break;
  }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0x6, %rax
ja 0x9a48
movq 0x8(%rsp), %rax
leaq 0xf0611(%rip), %rcx     # 0xfa004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, 0x14(%rsp)
jmp 0x9a9f
movl $0x2, 0x14(%rsp)
jmp 0x9a9f
movl $0x1, 0x14(%rsp)
jmp 0x9a9f
movl $0x6, 0x14(%rsp)
jmp 0x9a9f
movl $0x5, 0x14(%rsp)
jmp 0x9a9f
movl $0x4, 0x14(%rsp)
jmp 0x9a9f
movl $0x3, 0x14(%rsp)
jmp 0x9a9f
movq 0x142599(%rip), %rdi    # 0x14bfe8
leaq 0xf06a2(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0xf069c(%rip), %rsi     # 0xfa101
callq 0x8330
movq %rax, %rdi
leaq 0xf1976(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x1d, %esi
callq 0x8650
movq %rax, %rdi
movq 0x1424f0(%rip), %rsi    # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/arm.cpp
// Function: arm::Operand2::CheckImm8m(int)
bool Operand2::CheckImm8m(int imm) {
  // NOTE: assign a int to unsigned int
  unsigned int encoding = imm;
  for (int ror = 0; ror < 32; ror += 2) {
    // 如果encoding的前24bit都是0 说明imm能被表示成一个8bit循环右移偶数位得到
    if (!(encoding & ~0xFFu)) {
      return true;
    }
    encoding = (encoding << 30u) | (encoding >> 2u);
  }
  return false;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
cmpl $0x20, -0x10(%rsp)
jge 0xa4a1
movl -0xc(%rsp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
cmpl $0x0, %eax
jne 0xa480
movb $0x1, -0x1(%rsp)
jmp 0xa4a6
movl -0xc(%rsp), %eax
shll $0x1e, %eax
movl -0xc(%rsp), %ecx
shrl $0x2, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rsp)
jmp 0xa464
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: luooofan[P]hblzbd_compiler/src/arm.cpp
// Function: arm::Instruction::Instruction(arm::Instruction*)
Instruction::Instruction(Instruction* inst) : parent_(inst->parent_) {
  auto& inst_list = parent_->inst_list_;
  auto it = std::find(inst_list.begin(), inst_list.end(), inst);
  MyAssert(it != inst_list.end());
  inst_list.insert(it, this);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x13fd51(%rip), %rcx    # 0x14a300
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x58(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq 0x8(%rax), %rax
addq $0x30, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0xcaa0
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0xcad0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0xca40
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0xcad0
movq %rax, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xcb00
xorb $-0x1, %al
testb $0x1, %al
jne 0xa634
jmp 0xa68b
movq 0x1419ad(%rip), %rdi    # 0x14bfe8
leaq 0xefab6(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0xefab0(%rip), %rsi     # 0xfa101
callq 0x8330
movq %rax, %rdi
leaq 0xf0d8a(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x6f, %esi
callq 0x8650
movq %rax, %rdi
movq 0x141904(%rip), %rsi    # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xcb80
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xcb40
movq %rax, 0x18(%rsp)
addq $0x68, %rsp
retq
nopl (%rax)
// File: luooofan[P]hblzbd_compiler/src/arm.cpp
// Function: arm::Move::EmitCode(std::ostream&)
void Move::EmitCode(std::ostream& outfile) {
  std::string opcode = this->is_mvn_ ? "mvn" : "mov";
  if (this->HasS()) opcode += "s";
  opcode += CondToString(this->cond_);
  outfile << "\t" << opcode << " " << std::string(*this->rd_);
  outfile << ", " << std::string(*this->op2_) << std::endl;
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x48(%rsp)
testb $0x1, 0x14(%rax)
je 0xad88
leaq 0xef3d9(%rip), %rax     # 0xfa15a
movq %rax, 0x40(%rsp)
jmp 0xad96
leaq 0xf28b3(%rip), %rax     # 0xfd642
movq %rax, 0x40(%rsp)
jmp 0xad96
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0xc7(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x8680
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0xc8(%rsp), %rdi
callq 0xc570
jmp 0xadcb
leaq 0xc7(%rsp), %rdi
callq 0x83c0
movq 0x48(%rsp), %rdi
callq 0xcc20
movb %al, 0x2f(%rsp)
jmp 0xade8
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0xadf2
jmp 0xae49
leaq 0xf159b(%rip), %rsi     # 0xfc394
leaq 0xc8(%rsp), %rdi
callq 0x8320
jmp 0xae08
jmp 0xae49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0xc7(%rsp), %rdi
callq 0x83c0
jmp 0xafe4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0xafd7
movq 0x48(%rsp), %rax
movl 0x10(%rax), %esi
leaq 0x90(%rsp), %rdi
callq 0x9ab0
jmp 0xae60
leaq 0xc8(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x84b0
jmp 0xae77
leaq 0x90(%rsp), %rdi
callq 0x8728
movq 0xe8(%rsp), %rdi
leaq 0xef2c5(%rip), %rsi     # 0xfa158
callq 0x8330
movq %rax, 0x20(%rsp)
jmp 0xae9f
movq 0x20(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x8310
movq %rax, 0x18(%rsp)
jmp 0xaeb8
movq 0x18(%rsp), %rdi
leaq 0xef491(%rip), %rsi     # 0xfa355
callq 0x8330
movq %rax, 0x10(%rsp)
jmp 0xaed0
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rsi
leaq 0x70(%rsp), %rdi
callq 0xc8f0
jmp 0xaee5
movq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x8310
jmp 0xaef6
leaq 0x70(%rsp), %rdi
callq 0x8728
movq 0xe8(%rsp), %rdi
leaq 0xef260(%rip), %rsi     # 0xfa16f
callq 0x8330
movq %rax, 0x8(%rsp)
jmp 0xaf1b
movq 0x48(%rsp), %rax
movq 0x20(%rax), %rsi
leaq 0x50(%rsp), %rdi
callq 0xa180
jmp 0xaf30
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x8310
movq %rax, (%rsp)
jmp 0xaf45
movq (%rsp), %rdi
movq 0x141030(%rip), %rsi    # 0x14bf80
callq 0x8380
jmp 0xaf57
leaq 0x50(%rsp), %rdi
callq 0x8728
leaq 0xc8(%rsp), %rdi
callq 0x8728
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x8728
jmp 0xafd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x8728
jmp 0xafd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x8728
leaq 0xc8(%rsp), %rdi
callq 0x8728
movq 0xb8(%rsp), %rdi
callq 0x8670
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/arm.cpp
// Function: arm::Branch::IsCall()
bool Branch::IsCall() {
  // 所有的标签都要由.开头
  if (this->has_l_ && this->label_.size() > 0 && this->label_ != "lr" && this->label_[0] != '.') {
    return true;
  } else {
    return false;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x38(%rax)
je 0xb0d5
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x8280
cmpq $0x0, %rax
jbe 0xb0d5
movq (%rsp), %rdi
addq $0x18, %rdi
leaq 0xef0b4(%rip), %rsi     # 0xfa15e
callq 0xcc30
testb $0x1, %al
jne 0xb0b5
jmp 0xb0d5
movq (%rsp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8710
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0xb0d5
movb $0x1, 0x17(%rsp)
jmp 0xb0da
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/arm.cpp
// Function: arm::Branch::EmitCode(std::ostream&)
void Branch::EmitCode(std::ostream& outfile) {
  std::string opcode = "b";
  if (this->has_l_) opcode += "l";
  // NOTE: only for bx lr
  if (this->has_x_) opcode += "x";
  opcode += CondToString(this->cond_);
  outfile << "\t" << opcode << " " << this->label_ << std::endl;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x8680
movq 0x28(%rsp), %rdx
leaq 0xf2885(%rip), %rsi     # 0xfda04
leaq 0x68(%rsp), %rdi
callq 0xc570
jmp 0xb18b
leaq 0x67(%rsp), %rdi
callq 0x83c0
movq 0x20(%rsp), %rax
testb $0x1, 0x38(%rax)
je 0xb1e5
leaq 0xf1116(%rip), %rsi     # 0xfc2bd
leaq 0x68(%rsp), %rdi
callq 0x8320
jmp 0xb1b3
jmp 0xb1e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x67(%rsp), %rdi
callq 0x83c0
jmp 0xb2dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xb2d2
movq 0x20(%rsp), %rax
testb $0x1, 0x39(%rax)
je 0xb205
leaq 0xef168(%rip), %rsi     # 0xfa35f
leaq 0x68(%rsp), %rdi
callq 0x8320
jmp 0xb203
jmp 0xb205
movq 0x20(%rsp), %rax
movl 0x10(%rax), %esi
leaq 0x30(%rsp), %rdi
callq 0x9ab0
jmp 0xb219
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x84b0
jmp 0xb22a
leaq 0x30(%rsp), %rdi
callq 0x8728
movq 0x88(%rsp), %rdi
leaq 0xeef15(%rip), %rsi     # 0xfa158
callq 0x8330
movq %rax, 0x18(%rsp)
jmp 0xb24f
movq 0x18(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x8310
movq %rax, 0x10(%rsp)
jmp 0xb265
movq 0x10(%rsp), %rdi
leaq 0xef0e4(%rip), %rsi     # 0xfa355
callq 0x8330
movq %rax, 0x8(%rsp)
jmp 0xb27d
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x18, %rsi
callq 0x8310
movq %rax, (%rsp)
jmp 0xb296
movq (%rsp), %rdi
movq 0x140cdf(%rip), %rsi    # 0x14bf80
callq 0x8380
jmp 0xb2a8
leaq 0x68(%rsp), %rdi
callq 0x8728
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x8728
leaq 0x68(%rsp), %rdi
callq 0x8728
movq 0x58(%rsp), %rdi
callq 0x8670
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/../include/arm.h
// Function: arm::LdrStr::HasUsedAsOp2(arm::Reg*)
virtual bool HasUsedAsOp2(Reg* reg) override {
    if (nullptr != offset_)
      return offset_->HasUsedAsOp2(reg);
    else
      return false;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
xorl %eax, %eax
cmpq 0x38(%rcx), %rax
je 0xd0eb
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xe870
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xd0f0
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/../include/arm.h
// Function: arm::LdrStr::HasUsedAsOp2WithoutShift(arm::Reg*)
virtual bool HasUsedAsOp2WithoutShift(Reg* reg) override {
    if (nullptr != offset_)
      return offset_->HasUsedAsOp2WithoutShift(reg);
    else
      return false;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
xorl %eax, %eax
cmpq 0x38(%rcx), %rax
je 0xd13b
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xe890
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xd140
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/arm_struct.cpp
// Function: ArmFunction::EmitCode(std::ostream&)
void ArmFunction::EmitCode(std::ostream& out) {
  out << ".global " << this->name_ << std::endl;
  out << "\t.type " << this->name_ << ", %function" << std::endl;
  out << this->name_ << ":" << std::endl;
#ifdef GENARM_WITH_COMMENT
  out << "@ call_func: ";
  for (auto func : this->call_func_list_) {
    out << func->name_ << " ";
  }
  out << std::endl;
  out << "@ arg_num: " << this->arg_num_ << " ";        // << std::endl;
  out << "@ stack_size: " << this->stack_size_ << " ";  // << std::endl;
  out << "@ virtual_reg_max: " << this->virtual_reg_max << " ";
  out << std::endl;
#endif
  out << "@ Function Begin:" << std::endl;
  for (auto bb : 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 0xe9dfd(%rip), %rsi     # 0xfa3a0
callq 0x8330
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x8310
movq %rax, %rdi
movq 0x13b9be(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x28(%rsp), %rdi
leaq 0xe9de7(%rip), %rsi     # 0xfa3ba
callq 0x8330
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x8310
movq %rax, %rdi
leaq 0xe9dfa(%rip), %rsi     # 0xfa3ec
callq 0x8330
movq %rax, %rdi
movq 0x13b97f(%rip), %rsi    # 0x14bf80
callq 0x8380
movq (%rsp), %rsi
movq 0x28(%rsp), %rdi
addq $0x8, %rsi
callq 0x8310
movq %rax, %rdi
leaq 0xeadc8(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movq 0x13b94f(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x28(%rsp), %rdi
leaq 0xe9db6(%rip), %rsi     # 0xfa3f8
callq 0x8330
movq %rax, %rdi
movq 0x13b92f(%rip), %rsi    # 0x14bf80
callq 0x8380
movq (%rsp), %rax
addq $0x38, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10bd0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10c00
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10c30
testb $0x1, %al
jne 0x10696
jmp 0x106d4
leaq 0x18(%rsp), %rdi
callq 0x10c70
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10700
movq 0x28(%rsp), %rdi
movq 0x13b8bd(%rip), %rsi    # 0x14bf80
callq 0x8380
leaq 0x18(%rsp), %rdi
callq 0x10c80
jmp 0x10681
movq 0x28(%rsp), %rdi
leaq 0xe9d2a(%rip), %rsi     # 0xfa40a
callq 0x8330
movq %rax, %rdi
movq 0x13b891(%rip), %rsi    # 0x14bf80
callq 0x8380
addq $0x38, %rsp
retq
nopl (%rax)
// File: luooofan[P]hblzbd_compiler/src/arm_struct.cpp
// Function: ArmBasicBlock::EmitCode(std::ostream&)
void ArmBasicBlock::EmitCode(std::ostream& out) {
  if (this->HasLabel()) {
    out << this->label_ << ":" << std::endl;
  }
#ifdef GENARM_WITH_COMMENT
  out << "  @ ID: " << this->IndexInFunc() << std::endl;
  out << "  @ BasicBlock Begin:" << std::endl;
  out << "  @ pred: ";
  for (auto pred : this->pred_) {
    out << GET_BB_IDENT(pred) << " ";
  }
  // out << std::endl;
  out << "  @ succ: ";
  for (auto succ : this->succ_) {
    out << GET_BB_IDENT(succ) << " ";
  }
  // out << std::endl;
  out << "  @ use: ";
  for (auto use : this->use_) {
    out << "r" << use << " ";
  }
  // out << std::endl;
  out << "  @ def: ";
  for (auto def : this->def_) {
    out << "r" << def << " ";
  }
  // out << std::endl;
  out << "  @ livein: ";
  for (auto livein : this->livein_) {
    out << "r" << livein << " ";
  }
  // out << std::endl;
  out << "  @ liveout: ";
  for (auto liveout : this->liveout_) {
    out << "r" << liveout << " ";
  }
  out << std::endl;
#endif
  for (auto inst : this->inst_list_) {
    inst->EmitCode(out);
  }
#ifdef GENARM_WITH_COMMENT
  out << "  @ BasicBlock End." << std::endl;
#endif
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x10ca0
testb $0x1, %al
jne 0x10722
jmp 0x10752
movq (%rsp), %rsi
movq 0x28(%rsp), %rdi
addq $0x8, %rsi
callq 0x8310
movq %rax, %rdi
leaq 0xeacac(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movq 0x13b833(%rip), %rsi    # 0x14bf80
callq 0x8380
movq (%rsp), %rax
addq $0x30, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xcaa0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xcad0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xcb00
testb $0x1, %al
jne 0x10792
jmp 0x107c0
leaq 0x18(%rsp), %rdi
callq 0xf5c0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x18(%rsp), %rdi
callq 0xf8f0
jmp 0x1077d
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/arm_struct.cpp
// Function: ArmBasicBlock::IndexInFunc()
int ArmBasicBlock::IndexInFunc() {
  MyAssert(nullptr != this->func_);
  auto& bbs = this->func_->bb_list_;
  MyAssert(std::find(bbs.begin(), bbs.end(), this) != bbs.end());
  return std::distance(bbs.begin(), std::find(bbs.begin(), bbs.end(), this));
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rcx
movq %rcx, (%rsp)
xorl %eax, %eax
cmpq 0x28(%rcx), %rax
jne 0x10841
movq 0x13b7f7(%rip), %rdi    # 0x14bfe8
leaq 0xe9900(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0xe9c13(%rip), %rsi     # 0xfa41a
callq 0x8330
movq %rax, %rdi
leaq 0xeabd4(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x9f, %esi
callq 0x8650
movq %rax, %rdi
movq 0x13b74e(%rip), %rsi    # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movq (%rsp), %rax
movq 0x28(%rax), %rax
addq $0x38, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x10bd0
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rdi
callq 0x10c00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rsp)
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x10cc0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x10c00
movq %rax, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x10c30
xorb $-0x1, %al
testb $0x1, %al
jne 0x108bb
jmp 0x10912
movq 0x13b726(%rip), %rdi    # 0x14bfe8
leaq 0xe982f(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0xe9b42(%rip), %rsi     # 0xfa41a
callq 0x8330
movq %rax, %rdi
leaq 0xeab03(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0xa1, %esi
callq 0x8650
movq %rax, %rdi
movq 0x13b67d(%rip), %rsi    # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movq 0x58(%rsp), %rdi
callq 0x10bd0
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
callq 0x10bd0
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
callq 0x10c00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x10cc0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x10d20
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::Root::PrintNode(int, std::ostream&)
void Root::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "Root" << LINE_NO << std::endl;
  for (const auto &ele : compunit_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 0xe8c70(%rip), %rsi     # 0xfa466
callq 0x8330
movq %rax, %rdi
leaq 0xea8f4(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe8c47(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x13a74d(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x14a20
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x14a50
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x14a80
testb $0x1, %al
jne 0x11879
jmp 0x118ae
leaq 0x20(%rsp), %rdi
callq 0x14ac0
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 0x14ad0
jmp 0x11864
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::ArrayIdentifier::PrintNode(int, std::ostream&)
void ArrayIdentifier::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "ArrayIdentifier" << LINE_NO << std::endl;
  name_.PRINT_NODE;
  ++indentation;
  PRINT_INDENT;
  outfile << "Shape" << LINE_NO << std::endl;
  for (const auto &ele : shape_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 0xe87ae(%rip), %rsi     # 0xfa484
callq 0x8330
movq %rax, %rdi
leaq 0xea414(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe8767(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x13a26d(%rip), %rsi    # 0x14bf80
callq 0x8380
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)
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 0xe873c(%rip), %rsi     # 0xfa494
callq 0x8330
movq %rax, %rdi
leaq 0xea392(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe86e5(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x13a1eb(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x14bc0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x14bf0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x14c20
testb $0x1, %al
jne 0x11ddb
jmp 0x11e15
leaq 0x20(%rsp), %rdi
callq 0x14c60
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x14c70
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 0x14c80
jmp 0x11dc6
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::ConditionExpression::PrintNode(int, std::ostream&)
void ConditionExpression::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "ConditionExpression OP: " << OP_STRING(this->op_) << LINE_NO
          << std::endl;
  this->lhs_.PRINT_NODE;
  this->rhs_.PRINT_NODE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe8544(%rip), %rsi     # 0xfa49a
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
subl $0x102, %eax            # imm = 0x102
cltq
leaq 0x13a46c(%rip), %rsi    # 0x14c3e0
shlq $0x5, %rax
addq %rax, %rsi
callq 0x8310
movq %rax, %rdi
leaq 0xea16f(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe84c2(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x139fc8(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::BinaryExpression::PrintNode(int, std::ostream&)
void BinaryExpression::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "BinaryExpression OP: " << OP_STRING(this->op_) << LINE_NO
          << std::endl;
  // this->lhs_.PRINT_NODE;
  this->lhs_->PRINT_NODE;
  this->rhs_.PRINT_NODE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe837d(%rip), %rsi     # 0xfa4b3
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
subl $0x102, %eax            # imm = 0x102
cltq
leaq 0x13a28c(%rip), %rsi    # 0x14c3e0
shlq $0x5, %rax
addq %rax, %rsi
callq 0x8310
movq %rax, %rdi
leaq 0xe9f8f(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe82e2(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x139de8(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x14c70
movq %rax, %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x28, %rsp
retq
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::UnaryExpression::PrintNode(int, std::ostream&)
void UnaryExpression::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "UnaryExpression OP: " << OP_STRING(this->op_) << LINE_NO
          << std::endl;
  this->rhs_.PRINT_NODE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe81d3(%rip), %rsi     # 0xfa4c9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
subl $0x102, %eax            # imm = 0x102
cltq
leaq 0x13a0cc(%rip), %rsi    # 0x14c3e0
shlq $0x5, %rax
addq %rax, %rsi
callq 0x8310
movq %rax, %rdi
leaq 0xe9dcf(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe8122(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x139c28(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::FunctionCall::PrintNode(int, std::ostream&)
void FunctionCall::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "FunctionCall" << LINE_NO << std::endl;
  this->name_.PRINT_NODE;
  this->args_.PRINT_NODE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe8028(%rip), %rsi     # 0xfa4de
callq 0x8330
movq %rax, %rdi
leaq 0xe9c34(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe7f87(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x139a8d(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::VariableDefineWithInit::PrintNode(int, std::ostream&)
void VariableDefineWithInit::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "DefineWithInit" << (is_const_ ? " const" : "") << LINE_NO
          << std::endl;
  name_.PRINT_NODE;
  value_.PRINT_NODE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe7cc5(%rip), %rsi     # 0xfa4eb
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movb 0xc(%rax), %cl
leaq 0xe791c(%rip), %rsi     # 0xfa159
leaq 0xe7cb6(%rip), %rax     # 0xfa4fa
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x8330
movq %rax, %rdi
leaq 0xe989f(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe7bf2(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x1396f8(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::ArrayDefineWithInit::PrintNode(int, std::ostream&)
void ArrayDefineWithInit::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "DefineWithInit" << (is_const_ ? " const" : "") << LINE_NO
          << std::endl;
  name_.PRINT_NODE;
  value_.PRINT_NODE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe7965(%rip), %rsi     # 0xfa4eb
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movb 0xc(%rax), %cl
leaq 0xe75bc(%rip), %rsi     # 0xfa159
leaq 0xe7956(%rip), %rax     # 0xfa4fa
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x8330
movq %rax, %rdi
leaq 0xe953f(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe7892(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x139398(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::FunctionDefine::PrintNode(int, std::ostream&)
void FunctionDefine::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "FunctionDefine" << LINE_NO << std::endl;

  ++indentation;
  PRINT_INDENT;
  outfile << "ReturnType: " << TYPE_STRING(this->return_type_) << LINE_NO
          << std::endl;
  --indentation;

  this->name_.PRINT_NODE;
  this->args_.PRINT_NODE;
  this->body_.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 0xe773b(%rip), %rsi     # 0xfa501
callq 0x8330
movq %rax, %rdi
leaq 0xe9324(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe7677(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x13917d(%rip), %rsi    # 0x14bf80
callq 0x8380
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %edi
movq 0x20(%rsp), %rsi
callq 0x11640
movq 0x20(%rsp), %rdi
leaq 0xe76e3(%rip), %rsi     # 0xfa510
callq 0x8330
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
cmpl $0x121, 0xc(%rax)       # imm = 0x121
jne 0x12e56
leaq 0xe7cb7(%rip), %rax     # 0xfab06
movq %rax, 0x8(%rsp)
jmp 0x12e7b
movq 0x10(%rsp), %rax
movl 0xc(%rax), %edx
leaq 0xe92a9(%rip), %rax     # 0xfc10e
leaq 0xe76b1(%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 0xe9265(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe75b8(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x1390be(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x10(%rsp), %rax
movl 0x2c(%rsp), %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c(%rsp)
movq 0x10(%rax), %rdi
movl 0x2c(%rsp), %esi
addl $0x1, %esi
movq 0x20(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x2c(%rsp), %esi
addl $0x1, %esi
movq 0x20(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x2c(%rsp), %esi
addl $0x1, %esi
movq 0x20(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::AssignStatement::PrintNode(int, std::ostream&)
void AssignStatement::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "AssignStatement" << LINE_NO << std::endl;
  this->lhs_.PRINT_NODE;
  this->rhs_.PRINT_NODE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe747c(%rip), %rsi     # 0xfa522
callq 0x8330
movq %rax, %rdi
leaq 0xe9044(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe7397(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x138e9d(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::IfElseStatement::~IfElseStatement()
IfElseStatement::~IfElseStatement() {
  delete &(this->cond_);
  delete &(this->thenstmt_);
  if (nullptr != this->elsestmt_) {
    delete this->elsestmt_;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x13772e(%rip), %rcx    # 0x14a8e8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x131db
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x131fa
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rcx), %rax
je 0x13226
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x13224
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x13226
movq 0x10(%rsp), %rdi
callq 0x15440
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::IfElseStatement::PrintNode(int, std::ostream&)
void IfElseStatement::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "IfElseStatement" << LINE_NO << std::endl;

  ++indentation;
  PRINT_INDENT;
  outfile << "Condition" << LINE_NO << std::endl;
  this->cond_.PRINT_NODE;
  PRINT_INDENT;
  outfile << "Then" << LINE_NO << std::endl;
  this->thenstmt_.PRINT_NODE;

  if (nullptr != this->elsestmt_) {
    PRINT_INDENT;
    outfile << "Else" << LINE_NO << std::endl;
    this->elsestmt_->PRINT_NODE;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe728c(%rip), %rsi     # 0xfa532
callq 0x8330
movq %rax, %rdi
leaq 0xe8e44(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe7197(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x138c9d(%rip), %rsi    # 0x14bf80
callq 0x8380
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe7235(%rip), %rsi     # 0xfa542
callq 0x8330
movq %rax, %rdi
leaq 0xe8ddd(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe7130(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x138c36(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe71c8(%rip), %rsi     # 0xfa54c
callq 0x8330
movq %rax, %rdi
leaq 0xe8d66(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe70b9(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x138bbf(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rcx), %rax
je 0x13465
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe7149(%rip), %rsi     # 0xfa551
callq 0x8330
movq %rax, %rdi
leaq 0xe8ce2(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe7035(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x138b3b(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::WhileStatement::PrintNode(int, std::ostream&)
void WhileStatement::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "WhileStatement" << LINE_NO << std::endl;

  ++indentation;
  PRINT_INDENT;
  outfile << "Condition" << LINE_NO << std::endl;
  this->cond_.PRINT_NODE;

  PRINT_INDENT;
  outfile << "Body" << LINE_NO << std::endl;
  this->bodystmt_.PRINT_NODE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe6fb0(%rip), %rsi     # 0xfa556
callq 0x8330
movq %rax, %rdi
leaq 0xe8b44(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe6e97(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x13899d(%rip), %rsi    # 0x14bf80
callq 0x8380
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe6f35(%rip), %rsi     # 0xfa542
callq 0x8330
movq %rax, %rdi
leaq 0xe8add(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe6e30(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x138936(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe6ee1(%rip), %rsi     # 0xfa565
callq 0x8330
movq %rax, %rdi
leaq 0xe8a66(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe6db9(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x1388bf(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::ReturnStatement::PrintNode(int, std::ostream&)
void ReturnStatement::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "ReturnStatement" << LINE_NO << std::endl;
  if (nullptr != this->value_) {
    this->value_->PRINT_NODE;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11640
movq 0x10(%rsp), %rdi
leaq 0xe6bf3(%rip), %rsi     # 0xfa579
callq 0x8330
movq %rax, %rdi
leaq 0xe8764(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe6ab7(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x1385bd(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
je 0x139f0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::Block::PrintNode(int, std::ostream&)
void Block::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "Block" << LINE_NO << std::endl;
  for (const auto &ele : this->statement_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 0xe6806(%rip), %rsi     # 0xfa59c
callq 0x8330
movq %rax, %rdi
leaq 0xe8354(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe66a7(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x1381ad(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x14cf0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x14d20
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x14d50
testb $0x1, %al
jne 0x13e19
jmp 0x13e4e
leaq 0x20(%rsp), %rdi
callq 0x14d90
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 0x14da0
jmp 0x13e04
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::DeclareStatement::PrintNode(int, std::ostream&)
void DeclareStatement::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "DeclareStatement Type: " << TYPE_STRING(this->type_) << LINE_NO
          << std::endl;
  for (const auto &ele : define_list_) {
    ele->PRINT_NODE;
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x4c(%rsp), %edi
movq 0x40(%rsp), %rsi
callq 0x11640
movq 0x40(%rsp), %rdi
leaq 0xe65cc(%rip), %rsi     # 0xfa5a2
callq 0x8330
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
cmpl $0x121, 0xc(%rax)       # imm = 0x121
jne 0x13fff
leaq 0xe6b0e(%rip), %rax     # 0xfab06
movq %rax, 0x8(%rsp)
jmp 0x14024
movq 0x10(%rsp), %rax
movl 0xc(%rax), %edx
leaq 0xe8100(%rip), %rax     # 0xfc10e
leaq 0xe6508(%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 0xe80bc(%rip), %rsi     # 0xfc0f9
callq 0x8330
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x8650
movq %rax, %rdi
leaq 0xe640f(%rip), %rsi     # 0xfa46b
callq 0x8330
movq %rax, %rdi
movq 0x137f15(%rip), %rsi    # 0x14bf80
callq 0x8380
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x14e30
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x14e60
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x14e90
testb $0x1, %al
jne 0x140b1
jmp 0x140e6
leaq 0x30(%rsp), %rdi
callq 0x14ed0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl 0x4c(%rsp), %esi
addl $0x1, %esi
movq 0x40(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x30(%rsp), %rdi
callq 0x14ee0
jmp 0x1409c
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::ArrayInitVal::~ArrayInitVal()
ArrayInitVal::~ArrayInitVal() {
  if (nullptr != this->value_) {
    delete this->value_;
  }
  for (auto &ptr : this->initval_list_) {
    delete ptr;
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x13689e(%rip), %rax    # 0x14aa08
addq $0x10, %rax
movq %rax, (%rcx)
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
je 0x1419a
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x14198
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1419a
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x14f70
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x14fa0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x14fd0
testb $0x1, %al
jne 0x141db
jmp 0x14216
leaq 0x30(%rsp), %rdi
callq 0x15010
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x14208
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1420a
leaq 0x30(%rsp), %rdi
callq 0x15020
jmp 0x141c6
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x15040
addq $0x48, %rsp
retq
nopl (%rax)