LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xb484
leaq 0x4a5bf(%rip), %rsi     # 0x564c8
movq %rbx, %rdi
callq 0x8240
leaq 0x4a5bf(%rip), %rcx     # 0x564d7
leaq 0x4a22a(%rip), %rsi     # 0x56149
cmpb $0x0, 0xc(%r14)
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x8240
leaq 0x4c0d2(%rip), %rsi     # 0x58009
movq %rax, %rdi
callq 0x8240
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x4a4f6(%rip), %rsi     # 0x56448
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x10(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xb484
leaq 0x4a4b3(%rip), %rsi     # 0x564de
movq %rbx, %rdi
callq 0x8240
leaq 0x4bfcf(%rip), %r15     # 0x58009
movq %rax, %rdi
movq %r15, %rsi
callq 0x8240
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x4a3f0(%rip), %r12     # 0x56448
movq %rax, %rdi
movq %r12, %rsi
callq 0x8240
movq %rax, %rdi
callq 0x8170
incl %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0xb484
leaq 0x4a46f(%rip), %rsi     # 0x564ed
movq %rbx, %rdi
callq 0x8240
movl 0xc(%r14), %ecx
cmpl $0x122, %ecx            # imm = 0x122
leaq 0x4a463(%rip), %rdx     # 0x564fa
leaq 0x4bf80(%rip), %rdi     # 0x5801e
cmoveq %rdx, %rdi
cmpl $0x121, %ecx            # imm = 0x121
leaq 0x4aa40(%rip), %rsi     # 0x56aef
cmovneq %rdi, %rsi
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
movq %r15, %rsi
callq 0x8240
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
movq %r12, %rsi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x18(%rax)
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xb484
leaq 0x4a35a(%rip), %rsi     # 0x564ff
movq %rbx, %rdi
callq 0x8240
leaq 0x4be55(%rip), %rsi     # 0x58009
movq %rax, %rdi
callq 0x8240
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x4a279(%rip), %rsi     # 0x56448
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x10(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
leaq 0x7373d(%rip), %rax     # 0x7f968
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc23d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xc24c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xc25c
movq (%rdi), %rax
popq %rbx
jmpq *0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movl %esi, %edi
movq %rdx, %rsi
callq 0xb484
leaq 0x4a276(%rip), %rsi     # 0x5650f
movq %rbx, %rdi
callq 0x8240
leaq 0x4bd61(%rip), %r12     # 0x58009
movq %rax, %rdi
movq %r12, %rsi
callq 0x8240
movl 0x8(%r15), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x4a182(%rip), %r13     # 0x56448
movq %rax, %rdi
movq %r13, %rsi
callq 0x8240
movq %rax, %rdi
callq 0x8170
leal 0x1(%r14), %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0xb484
leaq 0x4a231(%rip), %rsi     # 0x5651f
movq %rbx, %rdi
callq 0x8240
movq %rax, %rdi
movq %r12, %rsi
callq 0x8240
movl 0x8(%r15), %esi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
movq %r13, %rsi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x10(%r15), %rdi
addl $0x2, %r14d
movq (%rdi), %rax
movl %r14d, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movl %ebp, %edi
movq %rbx, %rsi
callq 0xb484
leaq 0x4a1e4(%rip), %rsi     # 0x56529
movq %rbx, %rdi
callq 0x8240
movq %rax, %rdi
movq %r12, %rsi
callq 0x8240
movl 0x8(%r15), %esi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
movq %r13, %rsi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x18(%r15), %rdi
movq (%rdi), %rax
movl %r14d, %esi
movq %rbx, %rdx
callq *0x18(%rax)
cmpq $0x0, 0x20(%r15)
je 0xc3fa
movl %ebp, %edi
movq %rbx, %rsi
callq 0xb484
leaq 0x4a18f(%rip), %rsi     # 0x5652e
movq %rbx, %rdi
callq 0x8240
leaq 0x4bc5b(%rip), %rsi     # 0x58009
movq %rax, %rdi
callq 0x8240
movl 0x8(%r15), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x4a07f(%rip), %rsi     # 0x56448
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x20(%r15), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movl %r14d, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movl %esi, %edi
movq %rdx, %rsi
callq 0xb484
leaq 0x4a0a8(%rip), %rsi     # 0x56533
movq %rbx, %rdi
callq 0x8240
leaq 0x4bb6f(%rip), %r12     # 0x58009
movq %rax, %rdi
movq %r12, %rsi
callq 0x8240
movl 0x8(%r15), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x49f90(%rip), %r13     # 0x56448
movq %rax, %rdi
movq %r13, %rsi
callq 0x8240
movq %rax, %rdi
callq 0x8170
leal 0x1(%r14), %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0xb484
leaq 0x4a03f(%rip), %rsi     # 0x5651f
movq %rbx, %rdi
callq 0x8240
movq %rax, %rdi
movq %r12, %rsi
callq 0x8240
movl 0x8(%r15), %esi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
movq %r13, %rsi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x10(%r15), %rdi
addl $0x2, %r14d
movq (%rdi), %rax
movl %r14d, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movl %ebp, %edi
movq %rbx, %rsi
callq 0xb484
leaq 0x4a00b(%rip), %rsi     # 0x56542
movq %rbx, %rdi
callq 0x8240
movq %rax, %rdi
movq %r12, %rsi
callq 0x8240
movl 0x8(%r15), %esi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
movq %r13, %rsi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x18(%r15), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movl %r14d, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xb484
leaq 0x49e91(%rip), %rsi     # 0x56556
movq %rbx, %rdi
callq 0x8240
leaq 0x4b935(%rip), %rsi     # 0x58009
movq %rax, %rdi
callq 0x8240
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x49d59(%rip), %rsi     # 0x56448
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xc71c
incl %ebp
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xb484
leaq 0x49ca5(%rip), %rsi     # 0x56579
movq %rbx, %rdi
callq 0x8240
leaq 0x4b726(%rip), %rsi     # 0x58009
movq %rax, %rdi
callq 0x8240
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x49b4a(%rip), %rsi     # 0x56448
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
incl %ebp
cmpq %r14, %r15
je 0xc931
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x18(%rax)
addq $0x8, %r15
jmp 0xc918
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xb484
leaq 0x49bad(%rip), %rsi     # 0x5657f
movq %rbx, %rdi
callq 0x8240
movl 0xc(%r14), %ecx
cmpl $0x122, %ecx            # imm = 0x122
leaq 0x49b0f(%rip), %rdx     # 0x564fa
leaq 0x4b62c(%rip), %rdi     # 0x5801e
cmoveq %rdx, %rdi
cmpl $0x121, %ecx            # imm = 0x121
leaq 0x4a0ec(%rip), %rsi     # 0x56aef
cmovneq %rdi, %rsi
movq %rax, %rdi
callq 0x8240
leaq 0x4b5f3(%rip), %rsi     # 0x58009
movq %rax, %rdi
callq 0x8240
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x49a17(%rip), %rsi     # 0x56448
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
incl %ebp
cmpq %r14, %r15
je 0xca64
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x18(%rax)
addq $0x8, %r15
jmp 0xca4b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x72fe7(%rip), %rax     # 0x7fa88
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xcab3
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%r14), %rbx
movq 0x18(%r14), %r15
movq 0x20(%r14), %r14
cmpq %r14, %r15
je 0xcad8
movq (%r15), %rdi
testq %rdi, %rdi
je 0xcad2
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
jmp 0xcabf
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xd08a
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movl %esi, %edi
movq %rdx, %rsi
callq 0xb484
leaq 0x49a79(%rip), %rsi     # 0x56597
movq %rbx, %rdi
callq 0x8240
leaq 0x4b4dc(%rip), %rsi     # 0x58009
movq %rax, %rdi
callq 0x8240
movl 0x8(%r15), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x49900(%rip), %rsi     # 0x56448
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
cmpb $0x1, 0xc(%r15)
jne 0xcb75
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xcb75
leal 0x1(%r14), %esi
movq (%rdi), %rax
movq %rbx, %rdx
callq *0x20(%rax)
movq 0x18(%r15), %r12
movq 0x20(%r15), %r15
incl %r14d
cmpq %r15, %r12
je 0xcb9b
movq (%r12), %rdi
movq (%rdi), %rax
movl %r14d, %esi
movq %rbx, %rdx
callq *0x20(%rax)
addq $0x8, %r12
jmp 0xcb80
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xb484
leaq 0x49999(%rip), %rsi     # 0x565a4
movq %rbx, %rdi
callq 0x8240
movl 0xc(%r14), %ecx
cmpl $0x122, %ecx            # imm = 0x122
leaq 0x498d6(%rip), %rdx     # 0x564fa
leaq 0x4b3f3(%rip), %rdi     # 0x5801e
cmoveq %rdx, %rdi
cmpl $0x121, %ecx            # imm = 0x121
leaq 0x49eb3(%rip), %rsi     # 0x56aef
cmovneq %rdi, %rsi
movq %rax, %rdi
callq 0x8240
leaq 0x4b3ba(%rip), %rsi     # 0x58009
movq %rax, %rdi
callq 0x8240
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x497de(%rip), %rsi     # 0x56448
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x10(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xb484
leaq 0x4989f(%rip), %rsi     # 0x565c3
movq %rbx, %rdi
callq 0x8240
leaq 0x4b2d6(%rip), %rsi     # 0x58009
movq %rax, %rdi
callq 0x8240
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x496fa(%rip), %rsi     # 0x56448
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
incl %ebp
cmpq %r14, %r15
je 0xcd91
cmpq %r14, %r15
je 0xcd86
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x18(%rax)
addq $0x8, %r15
jmp 0xcd6d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
movq %rbx, %rsi
callq 0xb484
leaq 0x4983d(%rip), %rsi     # 0x565df
movq %rbx, %rdi
callq 0x8240
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8170
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xb484
leaq 0x49797(%rip), %rsi     # 0x565e5
movq %rbx, %rdi
callq 0x8240
leaq 0x4b1ac(%rip), %rsi     # 0x58009
movq %rax, %rdi
callq 0x8240
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x495d0(%rip), %rsi     # 0x56448
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
incl %ebp
cmpq %r14, %r15
je 0xcebb
cmpq %r14, %r15
je 0xceb0
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x20(%rax)
addq $0x8, %r15
jmp 0xce97
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
movq %rbx, %rsi
callq 0xb484
leaq 0x49713(%rip), %rsi     # 0x565df
movq %rbx, %rdi
callq 0x8240
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8170
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %ebp
movq 0x10(%rdi), %rsi
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x8390
movl %ebp, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1d90c
leaq 0x50(%rsp), %rdi
callq 0x8578
movq 0x8(%rsp), %rax
testq %rax, %rax
jne 0xefac
movl 0x8(%r14), %ebp
movq 0x10(%r14), %rsi
leaq 0x479be(%rip), %rdx     # 0x56944
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xa334
movl %ebp, %edi
movq %r15, %rsi
callq 0x1f699
leaq 0x10(%rsp), %rdi
callq 0x8578
movq 0x8(%rsp), %rax
cmpb $0x0, 0x1(%rax)
jne 0xefe7
movl 0x8(%r14), %ebp
movq 0x10(%r14), %rsi
leaq 0x47998(%rip), %rdx     # 0x56959
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xa334
movl %ebp, %edi
movq %r14, %rsi
callq 0x1f699
leaq 0x10(%rsp), %rdi
callq 0x8578
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movl (%rax), %edx
leaq 0x10(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xf6ba
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1db84
leaq 0x18(%rsp), %rdi
callq 0x8578
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf025
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xf041
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0xf041
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/evaluate.cpp
// Function: ast::ArrayIdentifier::Evaluate(ir::ContextInfo&, std::vector<ir::IR*, std::allocator<ir::IR*>>&)
void ArrayIdentifier::Evaluate(ir::ContextInfo& ctx, std::vector<ir::IR*>& gIRList) {
  ir::SymbolTableItem* s = nullptr;
  int scope_id = ir::FindSymbol(ctx.scope_id_, name_.name_, s);
  if (!s) {
    ir::SemanticError(line_no_, name_.name_ + ": undefined variable");
  }
  if (shape_list_.size() != s->shape_.size()) {
    ir::SemanticError(line_no_, name_.name_ + ": the dimension of array is not correct");
  }

  int index, t;

  for (int i = 0; i < shape_list_.size(); ++i) {
    shape_list_[i]->Evaluate(ctx, gIRList);
    t = ctx.opn_.imm_num_;
    if (i == shape_list_.size() - 1) {
      index += t * 4;
    } else {
      index += t * s->width_[i + 1];
    }
  }

  ctx.opn_ = ir::Opn(ir::Opn::Type::Imm, s->initval_[index / 4]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rsp, %r12
andq $0x0, (%r12)
movq %rdi, %r15
movl (%rsi), %ebp
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rsi
leaq 0x48(%rsp), %r13
movq %r13, %rdi
callq 0x8390
movl %ebp, %edi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1d90c
leaq 0x48(%rsp), %rdi
callq 0x8578
movq (%rsp), %rdx
testq %rdx, %rdx
jne 0xf0dc
movl 0x8(%r15), %ebp
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
leaq 0x4788d(%rip), %rdx     # 0x56944
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xa334
movl %ebp, %edi
movq %r12, %rsi
callq 0x1f699
leaq 0x8(%rsp), %rdi
callq 0x8578
movq (%rsp), %rdx
movq 0x18(%r15), %rax
movq 0x20(%r15), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x4, %rsi
movq 0x10(%rdx), %rdi
subq 0x8(%rdx), %rdi
sarq $0x2, %rdi
cmpq %rdi, %rsi
je 0xf13b
movl 0x8(%r15), %ebp
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
leaq 0x47858(%rip), %rdx     # 0x5696a
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xa334
movl %ebp, %edi
movq %r12, %rsi
callq 0x1f699
leaq 0x8(%rsp), %rdi
callq 0x8578
movq 0x18(%r15), %rax
movq 0x20(%r15), %rcx
xorl %r12d, %r12d
xorl %r13d, %r13d
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r13, %rcx
jbe 0xf198
movq (%rax,%r12,4), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movq %r14, %rdx
callq *0x18(%rax)
movl 0xc(%rbx), %edx
movq 0x18(%r15), %rax
movq 0x20(%r15), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x4, %rsi
decq %rsi
cmpq %rsi, %r13
jne 0xf17f
shll $0x2, %edx
jmp 0xf18d
movq (%rsp), %rsi
movq 0x20(%rsi), %rsi
imull 0x4(%rsi,%r12), %edx
addl %edx, %ebp
incq %r13
addq $0x4, %r12
jmp 0xf141
movq (%rsp), %rcx
pushq $0x4
popq %rsi
movl %ebp, %eax
cltd
idivl %esi
cltq
movq 0x38(%rcx), %rcx
movl (%rcx,%rax,4), %edx
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xf6ba
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1db84
leaq 0x10(%rsp), %rdi
callq 0x8578
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf1e7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0xf203
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xf203
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/evaluate.cpp
// Function: ast::BinaryExpression::Evaluate(ir::ContextInfo&, std::vector<ir::IR*, std::allocator<ir::IR*>>&)
void BinaryExpression::Evaluate(ir::ContextInfo& ctx, std::vector<ir::IR*>& gIRList) {
  int l, r, res;

  // lhs_.Evaluate(ctx, gIRList);
  lhs_->Evaluate(ctx, gIRList);
  l = ctx.opn_.imm_num_;
  rhs_.Evaluate(ctx, gIRList);
  r = ctx.opn_.imm_num_;

  switch (op_) {
    case 258:
      res = l + r;
      break;
    case 259:
      res = l - r;
      break;
    case 261:
      res = l * r;
      break;
    case 262:
      res = l / r;
      break;
    case 263:
      res = l % r;
      break;
    case 270:
      res = l && r;
      break;
    case 271:
      res = l || r;
      break;
    default:
      // printf("mystery operator code: %d", op_);
      MyAssert(0);
      break;
  }

  ctx.opn_ = ir::Opn(ir::Opn::Type::Imm, res);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0xc(%rbx), %ebp
movq 0x20(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movq %r14, %rdx
callq *0x18(%rax)
movl $0xfffffefe, %eax       # imm = 0xFFFFFEFE
addl 0xc(%r15), %eax
cmpl $0xd, %eax
ja 0xf320
movl 0xc(%rbx), %ecx
leaq 0x47664(%rip), %rdx     # 0x5690c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
addl %ebp, %ecx
jmp 0xf2ea
movl %ebp, %eax
cltd
idivl %ecx
movl %edx, %ecx
jmp 0xf2ea
subl %ecx, %ebp
movl %ebp, %ecx
jmp 0xf2ea
testl %ebp, %ebp
setne %al
testl %ecx, %ecx
setne %cl
andb %al, %cl
movzbl %cl, %ecx
jmp 0xf2ea
imull %ebp, %ecx
jmp 0xf2ea
movl %ebp, %eax
cltd
idivl %ecx
jmp 0xf2e8
xorl %eax, %eax
orl %ecx, %ebp
setne %al
movl %eax, %ecx
addq $0x8, %rbx
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %ecx, %edx
callq 0xf6ba
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1db84
leaq 0x10(%rsp), %rdi
callq 0x8578
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x71cc1(%rip), %rdi     # 0x80fe8
leaq 0x46dba(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x4767f(%rip), %rsi     # 0x569b9
movq %rax, %rdi
callq 0x8240
leaq 0x47fd7(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x57
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x84d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0xc(%rbx), %edx
movl 0xc(%r14), %eax
cmpl $0x102, %eax            # imm = 0x102
je 0xf3c4
cmpl $0x104, %eax            # imm = 0x104
je 0xf3bb
cmpl $0x103, %eax            # imm = 0x103
jne 0xf3f5
negl %edx
jmp 0xf3c4
xorl %eax, %eax
testl %edx, %edx
sete %al
movl %eax, %edx
addq $0x8, %rbx
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xf6ba
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1db84
leaq 0x10(%rsp), %rdi
callq 0x8578
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq 0x71bec(%rip), %rdi     # 0x80fe8
leaq 0x46ce5(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x475aa(%rip), %rsi     # 0x569b9
movq %rax, %rdi
callq 0x8240
leaq 0x47f02(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x6f
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/generate_ir.cpp
// Function: ast::Identifier::GenerateIR(ir::ContextInfo&, std::vector<ir::IR*, std::allocator<ir::IR*>>&)
void Identifier::GenerateIR(ir::ContextInfo &ctx, std::vector<ir::IR *> &gIRList) {
  bool is_assigned = ctx.is_assigned_;
  ctx.is_assigned_ = false;
  ir::SymbolTableItem *s = nullptr;
  int scope_id = ir::FindSymbol(ctx.scope_id_, name_, s);
  if (!s) {
    ir::SemanticError(line_no_, name_ + ": undefined variable");
  }

  // NOTE: 常量直接替换为立即数 作用域为当前作用域
  if (!is_assigned && s->is_const_ && !s->is_array_) {
    ctx.opn_ = ir::Opn(OpnType::Imm, s->initval_[0]);
    ctx.shape_.clear();
  } else {
    ctx.shape_ = s->shape_;
    ctx.opn_ = ir::Opn(OpnType::Var, name_, scope_id);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movb 0x209(%rsi), %r13b
movb $0x0, 0x209(%rsi)
movq %rsp, %r15
andq $0x0, (%r15)
movq %rdi, %r14
movl (%rsi), %ebp
movq 0x10(%rdi), %rsi
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x8390
movl %ebp, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1d90c
movl %eax, %ebp
leaq 0x68(%rsp), %rdi
callq 0x8578
movq (%rsp), %rsi
testq %rsi, %rsi
jne 0x102b0
movl 0x8(%r14), %r15d
movq 0x10(%r14), %rsi
leaq 0x466ba(%rip), %rdx     # 0x56944
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xa334
movl %r15d, %edi
movq %r12, %rsi
callq 0x1f699
leaq 0x8(%rsp), %rdi
callq 0x8578
movq (%rsp), %rsi
testb %r13b, %r13b
jne 0x102c0
cmpb $0x1, 0x1(%rsi)
jne 0x102c0
cmpb $0x0, (%rsi)
je 0x10326
addq $0x8, %rsi
leaq 0x50(%rbx), %rdi
callq 0x1a80a
movq 0x10(%r14), %rsi
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x8390
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x1a8d4
addq $0x8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1db84
leaq 0x10(%rsp), %rdi
callq 0x8578
leaq 0x48(%rsp), %rdi
callq 0x8578
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%rsi), %rax
movl (%rax), %edx
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xf6ba
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x1db84
leaq 0x10(%rsp), %rdi
callq 0x8578
movq 0x50(%rbx), %rax
cmpq %rax, 0x58(%rbx)
je 0x10314
movq %rax, 0x58(%rbx)
jmp 0x10314
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x10397
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x10397
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8578
jmp 0x10388
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x10397
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/generate_ir.cpp
// Function: ast::VariableDefine::GenerateIR(ir::ContextInfo&, std::vector<ir::IR*, std::allocator<ir::IR*>>&)
void VariableDefine::GenerateIR(ir::ContextInfo &ctx, std::vector<ir::IR *> &gIRList) {
  auto &scope = ir::gScopes[ctx.scope_id_];
  auto &symbol_table = scope.symbol_table_;
  // NOTE: 只需在当前作用域查找即可 找到则变量重定义
  const auto &var_iter = symbol_table.find(this->name_.name_);
  if (var_iter == symbol_table.end()) {
    auto tmp = new ir::SymbolTableItem(false, false);
    if (ctx.scope_id_ == 0) {
      tmp->initval_.push_back(0);
    } else {  // GenIR DECLARE
      // gIRList.push_back({IROpKind::ALLOCA, ir::Opn{OpnType::Var, this->name_.name_, ctx.scope_id_},
      //                        ir::Opn{OpnType::Imm, ir::kIntWidth}});
    }
    symbol_table.insert({this->name_.name_, *tmp});
    delete tmp;
  } else {
    ir::SemanticError(this->line_no_, this->name_.name_ + ": variable redefined");
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r12
movq %rdi, %r15
movslq (%rsi), %r14
leaq 0x6f521(%rip), %rax     # 0x81548
shlq $0x6, %r14
addq (%rax), %r14
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xf75e
testq %rax, %rax
je 0x12079
movl 0x8(%r15), %ebx
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
leaq 0x44b1d(%rip), %rdx     # 0x56b73
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa334
movl %ebx, %edi
movq %r14, %rsi
callq 0x1f699
leaq 0x8(%rsp), %rdi
callq 0x8578
jmp 0x120eb
pushq $0x50
popq %rdi
callq 0x8250
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1a960
cmpl $0x0, (%r12)
jne 0x120ab
movq %rbx, %rdi
addq $0x38, %rdi
leaq 0x8(%rsp), %rsi
andl $0x0, (%rsi)
callq 0x1c9ca
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1ac9a
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c154
leaq 0x8(%rsp), %rdi
callq 0x1aa18
movq %rbx, %rdi
callq 0x1aa2e
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0x8260
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x1aa18
jmp 0x12123
movq %rax, %r14
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0x8260
jmp 0x12123
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8578
movq %r14, %rdi
callq 0x84d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %ebp
cmpb $0x0, 0x208(%rsi)
jne 0x146fd
leaq 0x6ce91(%rip), %rdi     # 0x81548
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x6, %rax
movl %eax, (%rbx)
leaq 0x30(%rsp), %rcx
movq %rcx, -0x30(%rcx)
movq $0x1, -0x28(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rcx)
movl $0x3f800000, -0x10(%rcx) # imm = 0x3F800000
movups %xmm0, -0x8(%rcx)
movl %eax, 0x8(%rcx)
movl %ebp, 0xc(%rcx)
movq %rsp, %rsi
callq 0x1bc58
movq %rsp, %rdi
callq 0x1b358
movb $0x0, 0x208(%rbx)
movq 0x10(%r15), %r12
movq 0x18(%r15), %r15
cmpq %r15, %r12
je 0x14727
movq (%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movq %r14, %rdx
callq *0x10(%rax)
addq $0x8, %r12
jmp 0x1470c
movl %ebp, (%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1b358
movq %rbx, %rdi
callq 0x84d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x39c16(%rip), %rsi     # 0x57192
movq %rbx, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
leaq 0x39c06(%rip), %rsi     # 0x57199
movq %rax, %rdi
callq 0x8240
movl 0x38(%r14), %esi
movq %rax, %rdi
callq 0x84b0
leaq 0x39bf8(%rip), %rsi     # 0x571a6
movq %rax, %rdi
callq 0x8240
movl 0x3c(%r14), %esi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
cmpq $0x0, 0x18(%r14)
je 0x1d62e
movq (%rbx), %rax
movq -0x18(%rax), %rax
pushq $0xa
popq %r15
movq %r15, 0x10(%rbx,%rax)
leaq 0x39b7f(%rip), %rsi     # 0x57167
movq %rbx, %rdi
callq 0x8240
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r15, 0x10(%rax,%rcx)
leaq 0x39bb7(%rip), %rsi     # 0x571ba
movq %rax, %rdi
callq 0x8240
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r15, 0x10(%rax,%rcx)
leaq 0x39ba5(%rip), %rsi     # 0x571c3
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
addq $0x10, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x1d664
leaq 0x8(%r14), %rsi
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xa, 0x10(%rbx,%rax)
movq %rbx, %rdi
callq 0x8230
leaq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x1d7b2
jmp 0x1d632
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x39ae4(%rip), %rsi     # 0x5715c
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq (%rbx), %rax
movq -0x18(%rax), %rax
pushq $0xa
popq %r14
movq %r14, 0x10(%rbx,%rax)
leaq 0x39acb(%rip), %rsi     # 0x57167
movq %rbx, %rdi
callq 0x8240
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
leaq 0x39ab5(%rip), %rsi     # 0x5716c
movq %rax, %rdi
callq 0x8240
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
leaq 0x39aa3(%rip), %rsi     # 0x57175
movq %rax, %rdi
callq 0x8240
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
leaq 0x39a8d(%rip), %rsi     # 0x5717a
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
leaq 0x63e6c(%rip), %r14     # 0x81570
movq (%r14), %r14
testq %r14, %r14
je 0x1d736
leaq 0x8(%r14), %rsi
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xa, 0x10(%rbx,%rax)
movq %rbx, %rdi
callq 0x8230
leaq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x1d73e
jmp 0x1d704
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq -0x18(%rax), %rax
pushq $0xa
popq %r12
movq %r12, 0x10(%rsi,%rax)
leaq 0x399ab(%rip), %r13     # 0x57183
cmpb $0x0, (%rdi)
leaq 0x399a5(%rip), %r15     # 0x57187
movq %r15, %rsi
cmovneq %r13, %rsi
movq %rbx, %rdi
callq 0x8240
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r12, 0x10(%rax,%rcx)
cmpb $0x0, 0x1(%r14)
cmovneq %r13, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x8240
cmpb $0x1, (%r14)
jne 0x1d879
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xa, 0x10(%rbx,%rax)
leaq 0x3995c(%rip), %rsi     # 0x5718a
movq %rbx, %rdi
callq 0x8240
movq 0x8(%r14), %r12
movq 0x10(%r14), %r13
leaq 0x38914(%rip), %r14     # 0x56159
leaq 0x399dc(%rip), %r15     # 0x57228
cmpq %r13, %r12
je 0x1d879
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8240
movl (%r12), %esi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x8240
addq $0x4, %r12
jmp 0x1d84c
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8170
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
testl %esi, %esi
js 0x1d8be
addq $0x38, %rdi
movq 0x63cae(%rip), %rax     # 0x81548
movl (%rdi), %ecx
cmpl %esi, %ecx
je 0x1d8b6
cmpl $-0x1, %ecx
je 0x1d8b6
movslq %ecx, %rcx
shlq $0x6, %rcx
leaq (%rax,%rcx), %rdi
addq $0x3c, %rdi
jmp 0x1d89a
cmpl $-0x1, %ecx
setne %al
popq %rcx
retq
movq 0x63723(%rip), %rdi     # 0x80fe8
leaq 0x3881c(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x398f4(%rip), %rsi     # 0x571cc
movq %rax, %rdi
callq 0x8240
leaq 0x39a39(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x46
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %r12d, %r12d
cmpl $-0x1, %ebp
je 0x1d94f
movslq %ebp, %r15
shlq $0x6, %r15
addq 0x63c16(%rip), %r15     # 0x81548
movq %r15, %rdi
movq %r14, %rsi
callq 0xf75e
testq %rax, %rax
jne 0x1d948
movl 0x3c(%r15), %ebp
jmp 0x1d91f
addq $0x28, %rax
movq %rax, %r12
movq %r12, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
movl 0x28(%rsi), %eax
movl %eax, 0x28(%rdi)
movl 0x38(%rsi), %eax
movl %eax, 0x38(%rdi)
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x81a0
movq 0x30(%rbx), %r15
testq %r15, %r15
je 0x1db06
leaq 0x8(%r15), %rdi
callq 0x8578
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x8260
andq $0x0, 0x30(%rbx)
movq 0x30(%r14), %r15
testq %r15, %r15
je 0x1db29
pushq $0x40
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x1da22
movq %r14, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
movl 0x28(%rsi), %eax
movl %eax, 0x28(%rdi)
movl 0x38(%rsi), %eax
movl %eax, 0x38(%rdi)
movq 0x30(%rdi), %r15
testq %r15, %r15
je 0x1dbc3
leaq 0x8(%r15), %rdi
callq 0x8578
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x8260
andq $0x0, 0x30(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
addq $0x8, %r14
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x8320
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ir.cpp
// Function: ir::Opn::GetCompName[abi:cxx11]()
std::string Opn::GetCompName() {  // 对于全局变量直接返回原name_ 对于局部变量返回复合name
  if (type_ == Type::Imm || type_ == Type::Null) MyAssert(0);
  if (type_ == Type::Label || type_ == Type::Func || scope_id_ == 0) return name_;
  auto res = scope_id_ == -1 ? name_ : name_ + "." + std::to_string(scope_id_);
  return ssa_id_ == -1 ? res : res + "." + std::to_string(ssa_id_);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1dc41
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8390
jmp 0x1dd21
cmpl $0x4, %eax
je 0x1dd2c
cmpl $0x1, %eax
je 0x1dd2c
movl 0x28(%r14), %eax
testl %eax, %eax
je 0x1dc2d
leaq 0x8(%r14), %rsi
cmpl $-0x1, %eax
je 0x1dcad
leaq 0x3bac1(%rip), %rdx     # 0x5972c
leaq 0x28(%rsp), %rdi
callq 0xa334
movl 0x28(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0xa36c
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xa2cd
leaq 0x8(%rsp), %rdi
callq 0x8578
leaq 0x28(%rsp), %rdi
callq 0x8578
jmp 0x1dcb7
leaq 0x48(%rsp), %rdi
callq 0x8390
cmpl $-0x1, 0x38(%r14)
je 0x1dd0a
leaq 0x3ba67(%rip), %rdx     # 0x5972c
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xa334
movl 0x38(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0xa36c
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xa2cd
leaq 0x8(%rsp), %rdi
callq 0x8578
leaq 0x28(%rsp), %rdi
callq 0x8578
jmp 0x1dd17
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x8390
leaq 0x48(%rsp), %rdi
callq 0x8578
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq 0x632b5(%rip), %rdi     # 0x80fe8
leaq 0x383ae(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x39486(%rip), %rsi     # 0x571cc
movq %rax, %rdi
callq 0x8240
leaq 0x395cb(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
movl $0xb2, %esi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
jmp 0x1dd9c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8578
jmp 0x1dd90
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8578
jmp 0x1dd9f
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x1ddbd
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8578
jmp 0x1ddb8
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x36942(%rip), %rsi     # 0x562bc
movq %rbx, %rdi
callq 0x8240
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x8230
movq %rax, %rdi
callq 0x8170
movq 0x28(%r14), %r15
movq 0x30(%r14), %r14
cmpq %r14, %r15
je 0x1f9bc
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x1f9c2
movq %rbx, %rdi
callq 0x8170
addq $0x8, %r15
jmp 0x1f99e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x37891(%rip), %rsi     # 0x57265
movq %rbx, %rdi
callq 0x8240
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x8230
movq %rax, %rdi
callq 0x8170
leaq 0x369de(%rip), %rsi     # 0x563d5
movq %rbx, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq %rbx, %rdi
callq 0x8170
movq 0x30(%r14), %r15
movq 0x38(%r14), %r14
cmpq %r14, %r15
je 0x1fa35
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x1fad6
movq %rbx, %rdi
callq 0x8170
addq $0x8, %r15
jmp 0x1fa17
leaq 0x369ab(%rip), %rsi     # 0x563e7
movq %rbx, %rdi
callq 0x8240
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8170
nop