LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: MovInst::Print(std::ostream&)
void MovInst::Print(std::ostream &outfile) {
  Value::Print(outfile);
  outfile << std::setw(INDENT) << "=mov";
  User::Print(outfile);
  outfile << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x337b8
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%rbx,%rax)
leaq 0x3de54(%rip), %rsi     # 0x7251e
movl $0x4, %edx
movq %rbx, %rdi
callq 0x8330
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33a9e
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x81f0
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: PhiInst::Print(std::ostream&)
void PhiInst::Print(std::ostream &outfile) {
  Value::Print(outfile);
  outfile << std::setw(INDENT) << "=phi";
  User::Print(outfile);
  outfile << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x337b8
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%rbx,%rax)
leaq 0x3dded(%rip), %rsi     # 0x72523
movl $0x4, %edx
movq %rbx, %rdi
callq 0x8330
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33a9e
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x81f0
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: Value::~Value()
Value::~Value() {
  auto uses = GetUses();  // necessary. can't use reference
  for (auto use : uses) {
    use->Set(nullptr);  // necessary. when destruct a use instance, must ensure that its value_ is a valid pointer.
  }
  // 并没有删除使用它的那个user的operand 只是让operand的use中的value变为nullptr了
  MyAssert(!IsUsed());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x5ac8c(%rip), %rax     # 0x8f420
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x348e4
movq 0x10(%rsp), %r13
cmpq %r15, %r13
je 0x347e9
leaq 0x8(%rsp), %r12
movq 0x10(%r13), %rbp
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x347d8
movq %rbp, 0x8(%rsp)
addq $0x10, %rdi
movq %r12, %rsi
callq 0x34d82
movq $0x0, (%rbp)
movq (%r13), %r13
cmpq %r15, %r13
jne 0x347ba
cmpq %rbx, (%rbx)
jne 0x34851
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x3480d
movq (%rdi), %r12
movl $0x18, %esi
callq 0x82a0
movq %r12, %rdi
cmpq %r15, %r12
jne 0x347f8
movq 0x28(%r14), %rdi
addq $0x38, %r14
cmpq %r14, %rdi
je 0x34825
movq (%r14), %rsi
incq %rsi
callq 0x82a0
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x34842
movq (%rdi), %r14
movl $0x18, %esi
callq 0x82a0
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x3482d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5b798(%rip), %rdi     # 0x8fff0
leaq 0x3a909(%rip), %rsi     # 0x6f168
movl $0x8, %edx
callq 0x8330
movq 0x5b780(%rip), %rdi     # 0x8fff0
leaq 0x3dc6a(%rip), %rsi     # 0x724e1
movl $0xb, %edx
callq 0x8330
movq 0x5b768(%rip), %rdi     # 0x8fff0
leaq 0x3bb31(%rip), %rsi     # 0x703c0
movl $0x1, %edx
callq 0x8330
movq 0x5b750(%rip), %rdi     # 0x8fff0
movl $0x2c, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
movq %rax, %rdi
callq 0xc881
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/../include/ssa.h
// Function: Use::operator=(Use&&)
Use& operator=(Use&& u) {
    user_ = u.GetUser();
    Set(u.Get());
    u.Set(nullptr);
    return *this;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq (%rsi), %rsi
callq 0x34934
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3519d
movq %rsp, %rsi
movq %r14, (%rsi)
addq $0x10, %rdi
callq 0x34d82
movq $0x0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSAFunction::RemoveBasicBlock(SSABasicBlock*)
void SSAFunction::RemoveBasicBlock(SSABasicBlock* bb) {
  bb_list_.remove(bb);
  // TODO: manage memory
  for (auto pred : bb->GetPredBB()) {
    pred->RemoveSuccBB(bb);
  }
  for (auto succ : bb->GetSuccBB()) {
    succ->RemovePredBB(bb);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rsi, (%rbx)
addq $0x30, %rdi
movq %rbx, %rsi
callq 0x360b8
movq (%rbx), %r14
movq 0x40(%r14), %r15
addq $0x40, %r14
cmpq %r14, %r15
je 0x35411
leaq 0x8(%rsp), %rbx
movq 0x10(%r15), %rdi
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x58, %rdi
movq %rbx, %rsi
callq 0x360b8
movq (%r15), %r15
cmpq %r14, %r15
jne 0x353f0
movq (%rsp), %r14
movq 0x58(%r14), %r15
addq $0x58, %r14
cmpq %r14, %r15
je 0x35448
leaq 0x8(%rsp), %rbx
movq 0x10(%r15), %rdi
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x360b8
movq (%r15), %r15
cmpq %r14, %r15
jne 0x35427
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSAFunction::MaintainCallFunc()
void SSAFunction::MaintainCallFunc() {
  call_func_list_.clear();
  for (auto bb : bb_list_) {
    for (auto inst : bb->GetInstList()) {
      if (auto call_inst = dynamic_cast<CallInst*>(inst)) {
        auto func_val = dynamic_cast<FunctionValue*>(call_inst->GetOperand(0));
        MyAssert(nullptr != func_val);
        call_func_list_.insert(func_val->GetFunction());
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
movq %r14, %rdi
callq 0x36272
movq 0x30(%rbx), %rbp
addq $0x30, %rbx
movq %rbx, (%rsp)
cmpq %rbx, %rbp
je 0x35527
leaq 0x59f6d(%rip), %rbx     # 0x8f3f8
leaq 0x5a25e(%rip), %r13     # 0x8f6f0
movq 0x10(%rbp), %r15
movq 0x28(%r15), %r12
addq $0x28, %r15
cmpq %r15, %r12
je 0x35519
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x354bc
movq %rbx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x8320
jmp 0x354be
xorl %eax, %eax
testq %rax, %rax
je 0x35513
movq %rax, %rdi
xorl %esi, %esi
callq 0x33480
testq %rax, %rax
je 0x354ec
movq %rax, %rdi
leaq 0x59fd4(%rip), %rsi     # 0x8f4b0
leaq 0x5a025(%rip), %rdx     # 0x8f508
xorl %ecx, %ecx
callq 0x8320
jmp 0x354ee
xorl %eax, %eax
testq %rax, %rax
je 0x35536
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x365f2
movq (%r12), %r12
jmp 0x3549e
movq (%rbp), %rbp
cmpq (%rsp), %rbp
jne 0x35492
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5aab3(%rip), %rdi     # 0x8fff0
leaq 0x39c24(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x3cfde(%rip), %rsi     # 0x7252e
movq %rax, %rdi
callq 0x8280
leaq 0x3ae61(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x38, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSAFunction::~SSAFunction()
SSAFunction::~SSAFunction() {
  // m_ = nullptr;
  // delete value_; // FIXME: should be delete and remove all use
  for (auto bb : bb_list_) delete bb;
  // bb_list_.clear();
  // call_func_list_.clear();
  // used_glob_var_list_.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq 0x30(%rdi), %r12
cmpq %r15, %r12
je 0x35859
movq 0x10(%r12), %r14
testq %r14, %r14
je 0x35853
movq %r14, %rdi
callq 0x359f8
movl $0xd0, %esi
movq %r14, %rdi
callq 0x82a0
movq (%r12), %r12
jmp 0x3582f
leaq 0x80(%rbx), %rdi
callq 0x361dc
leaq 0x48(%rbx), %rdi
callq 0x3624c
movq 0x30(%rbx), %rdi
cmpq %r15, %rdi
je 0x3588c
movq (%rdi), %r14
movl $0x18, %esi
callq 0x82a0
movq %r14, %rdi
cmpq %r15, %r14
jne 0x35877
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x358ae
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x82a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSABasicBlock::GetNextBB()
SSABasicBlock* SSABasicBlock::GetNextBB() {
  // maybe return nullptr
  auto& bb_list = func_->GetBBList();
  auto it = ++std::find(bb_list.begin(), bb_list.end(), this);
  if (it == bb_list.end())
    return nullptr;
  else
    return *it;
}

// Assembly:
movq (%rdi), %rax
movq 0x30(%rax), %rcx
addq $0x30, %rax
cmpq %rax, %rcx
je 0x358d5
cmpq %rdi, 0x10(%rcx)
je 0x358d5
movq (%rcx), %rcx
jmp 0x358c5
movq (%rcx), %rcx
cmpq %rax, %rcx
je 0x358e2
movq 0x10(%rcx), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSABasicBlock::GetDomSet()
std::unordered_set<SSABasicBlock*> SSABasicBlock::GetDomSet() {
  // all ancestor in dom tree, including itself
  std::unordered_set<SSABasicBlock*> res;
  auto temp = this;
  while (nullptr != temp) {
    res.insert(temp);
    temp = temp->GetIDom();
  }
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
movq %rsp, %r14
movq %rsi, (%r14)
leaq 0x8(%rsp), %r15
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3632c
movq (%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, (%rsp)
testq %rax, %rax
jne 0x359b4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x362bc
movq %r14, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSABasicBlock::~SSABasicBlock()
SSABasicBlock::~SSABasicBlock() {
  // func_ = nullptr;
  // delete value_; // FIXME: should be delete and remove all use
  for (auto inst : inst_list_) {
    delete inst;
    // std::cout << "ok\n";
  }
  // inst_list_.clear();
  // pred_.clear();
  // succ_.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq 0x28(%rdi), %r15
cmpq %r14, %r15
je 0x35a24
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x35a1f
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r15), %r15
jmp 0x35a0b
leaq 0x90(%rbx), %rdi
callq 0x362bc
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x35a48
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x82a0
leaq 0x58(%rbx), %r15
movq 0x58(%rbx), %rdi
cmpq %r15, %rdi
je 0x35a6a
movq (%rdi), %r12
movl $0x18, %esi
callq 0x82a0
movq %r12, %rdi
cmpq %r15, %r12
jne 0x35a55
leaq 0x40(%rbx), %r15
movq 0x40(%rbx), %rdi
cmpq %r15, %rdi
je 0x35a8c
movq (%rdi), %r12
movl $0x18, %esi
callq 0x82a0
movq %r12, %rdi
cmpq %r15, %r12
jne 0x35a77
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x35aa9
movq (%rdi), %r15
movl $0x18, %esi
callq 0x82a0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x35a94
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x35acc
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x82a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSAModule::EmitCode(std::ostream&)
void SSAModule::EmitCode(std::ostream& out) {
  for (auto glob : glob_var_list_) {
    glob->Print(out);
  }
  out << std::endl;
  // for (auto func : builtin_func_list_) {
  //   func->EmitCode(out);
  //   out << std::endl;
  // }
  for (auto func : func_list_) {
    func->EmitCode(out);
    out << std::endl;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rdi), %r15
movq 0x28(%rdi), %r12
cmpq %r15, %r12
je 0x35b07
movq 0x10(%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq (%r12), %r12
jmp 0x35aee
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x40(%r14), %r15
addq $0x40, %r14
cmpq %r14, %r15
je 0x35b73
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x35b80
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq (%r15), %r15
jmp 0x35b36
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSABasicBlock::EmitCode(std::ostream&)
void SSABasicBlock::EmitCode(std::ostream& out) {
  out << label_ << ":" << std::endl;
  out << "; BB Begin:" << std::endl;
  for (auto inst : inst_list_) {
    inst->Print(out);
  }
  out << "; BB End." << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq %rbx, %rdi
callq 0x8330
movq %rax, %r15
leaq 0x3a4fb(%rip), %rsi     # 0x703c0
movl $0x1, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
leaq 0x3c69e(%rip), %rsi     # 0x7259e
movl $0xb, %edx
movq %rbx, %rdi
callq 0x8330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x28(%r14), %r15
addq $0x28, %r14
cmpq %r14, %r15
je 0x35f53
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq (%r15), %r15
jmp 0x35f3c
leaq 0x3c650(%rip), %rsi     # 0x725aa
movl $0x9, %edx
movq %rbx, %rdi
callq 0x8330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x81f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/allocate_register.cpp
// Function: RegAlloc::ValidAdjacentSet(int, std::unordered_map<int, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>>>>&, std::vector<int, std::allocator<int>>&, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>&)
RegAlloc::WorkList RegAlloc::ValidAdjacentSet(RegId reg, AdjList &adj_list, std::vector<RegId> &select_stack,
                                              WorkList &coalesced_nodes) {
  WorkList valid_adjacent = adj_list[reg];
  // outfile << valid_adjacent.size() << std::endl;
  for (auto iter = valid_adjacent.begin(); iter != valid_adjacent.end();) {
    // outfile << *iter << std::endl;
    // NOTE: erase
    if (std::find(select_stack.begin(), select_stack.end(), *iter) == select_stack.end() &&
        coalesced_nodes.find(*iter) == coalesced_nodes.end()) {
      ++iter;
    } else {
      iter = valid_adjacent.erase(iter);
    }
    // dbg_print_worklist(valid_adjacent, outfile);
  }
  return valid_adjacent;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
movl %edx, (%rsi)
movq %rcx, %rdi
callq 0x3b496
xorl %ecx, %ecx
movq %rcx, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movq 0x18(%rax), %rdx
movq %rdx, 0x18(%rbx)
movups 0x20(%rax), %xmm0
movups %xmm0, 0x20(%rbx)
movq %rcx, 0x30(%rbx)
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x39964
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0x36d48
movq (%r15), %rdi
movq 0x8(%r15), %rsi
leaq 0x8(%r12), %r13
movq %r13, %rdx
callq 0x3b7bf
cmpq 0x8(%r15), %rax
je 0x36d1c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3b858
movq %rax, %r12
jmp 0x36ced
movslq (%r13), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq 0x8(%r14)
movq %r14, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x39b62
testq %rax, %rax
je 0x36d42
cmpq $0x0, (%rax)
jne 0x36d0c
movq (%r12), %r12
jmp 0x36ced
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x36d5d
jmp 0x36d5d
movq %rax, %r14
movq %rbx, %rdi
callq 0x39aec
movq %r14, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/arm_liveness_analysis.cpp
// Function: ArmLivenessAnalysis::Run()
void ArmLivenessAnalysis::Run() {
  auto m = dynamic_cast<ArmModule *>(*(this->m_));
  MyAssert(nullptr != m);
  for (auto func : m->func_list_) {
    this->Run4Func(func);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3cd79
leaq 0x518af(%rip), %rsi     # 0x8e618
leaq 0x51890(%rip), %rdx     # 0x8e600
xorl %ecx, %ecx
callq 0x8320
jmp 0x3cd7b
xorl %eax, %eax
testq %rax, %rax
je 0x3cda3
movq 0x28(%rax), %rbx
movq 0x30(%rax), %r14
cmpq %r14, %rbx
je 0x3cd9b
movq (%rbx), %rdi
callq 0x3c9c0
addq $0x8, %rbx
jmp 0x3cd88
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x53246(%rip), %rdi     # 0x8fff0
leaq 0x323b7(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x35836(%rip), %rsi     # 0x725f3
movq %rax, %rdi
callq 0x8280
leaq 0x335f4(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0xd5, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/arm_offset_fixup.cpp
// Function: SPOffsetFixup::Run()
void SPOffsetFixup::Run() {
  auto m = dynamic_cast<ArmModule *>(*(this->m_));
  MyAssert(nullptr != m);
  for (auto func : m->func_list_) {
    Fixup4Func(func);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3d63f
leaq 0x50fe9(%rip), %rsi     # 0x8e618
leaq 0x50fca(%rip), %rdx     # 0x8e600
xorl %ecx, %ecx
callq 0x8320
jmp 0x3d641
xorl %eax, %eax
testq %rax, %rax
je 0x3d669
movq 0x28(%rax), %rbx
movq 0x30(%rax), %r14
cmpq %r14, %rbx
je 0x3d661
movq (%rbx), %rsi
callq 0x3d6ba
addq $0x8, %rbx
jmp 0x3d64e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x52980(%rip), %rdi     # 0x8fff0
leaq 0x31af1(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x34fb3(%rip), %rsi     # 0x72636
movq %rax, %rdi
callq 0x8280
leaq 0x32d2e(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0xd, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/cond_br_to_insts.cpp
// Function: CondBrToInsts::Run()
void CondBrToInsts::Run() {
  kCount = 0;
  auto m = dynamic_cast<ArmModule*>(*(this->m_));
  MyAssert(nullptr != m);
  for (auto func : m->func_list_) {
    Run4Func(func);
  }
#ifdef OUTPUT_CONDBRTOINSTS_EFFECT
  std::cout << "CondBrToInsts Pass works on: " << kCount << " ArmBBs" << std::endl;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x0, 0x521fe(%rip)     # 0x906d4
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3e4f9
leaq 0x5012f(%rip), %rsi     # 0x8e618
leaq 0x50110(%rip), %rdx     # 0x8e600
xorl %ecx, %ecx
callq 0x8320
jmp 0x3e4fb
xorl %eax, %eax
testq %rax, %rax
je 0x3e523
movq 0x28(%rax), %rbx
movq 0x30(%rax), %r14
cmpq %r14, %rbx
je 0x3e51b
movq (%rbx), %rsi
callq 0x3e574
addq $0x8, %rbx
jmp 0x3e508
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x51ac6(%rip), %rdi     # 0x8fff0
leaq 0x30c37(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x34127(%rip), %rsi     # 0x72664
movq %rax, %rdi
callq 0x8280
leaq 0x31e74(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x13, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/convert_ssa.cpp
// Function: ConvertSSA::Run()
void ConvertSSA::Run() {
  auto m = dynamic_cast<IRModule*>(*(this->m_));
  MyAssert(nullptr != m);
  for (auto f : m->func_list_) {
    InsertPhiIR(f);
    // f->EmitCode(std::cout);
    this->count_.clear();
    this->stack_.clear();
    Rename(f->bb_list_.front());
  }
  // m->EmitCode();
  auto ssam = this->ConstructSSA(m);
  *(this->m_) = static_cast<Module*>(ssam);
  delete m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3fc51
leaq 0x4e9d7(%rip), %rsi     # 0x8e618
leaq 0x4f430(%rip), %rdx     # 0x8f078
xorl %ecx, %ecx
callq 0x8320
jmp 0x3fc53
xorl %eax, %eax
testq %rax, %rax
je 0x3fcd2
movq 0x28(%rax), %rbp
movq %rax, (%rsp)
movq 0x30(%rax), %r14
cmpq %r14, %rbp
je 0x3fca5
leaq 0x38(%rbx), %r15
leaq 0x70(%rbx), %r12
movq (%rbp), %r13
movq %r13, %rsi
callq 0x3fd22
movq %r15, %rdi
callq 0x464c0
movq %r12, %rdi
callq 0x46984
movq 0x30(%r13), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4014a
addq $0x8, %rbp
cmpq %r14, %rbp
jne 0x3fc71
movq %rbx, %rdi
movq (%rsp), %r14
movq %r14, %rsi
callq 0x40af6
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x8(%rax)
movq 0x50317(%rip), %rdi     # 0x8fff0
leaq 0x2f488(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x32ab8(%rip), %rsi     # 0x727a4
movq %rax, %rdi
callq 0x8280
leaq 0x306c5(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x10, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/convert_ssa.cpp
// Function: ConvertSSA::FindValueFromCompName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
Value* ConvertSSA::FindValueFromCompName(const std::string& comp_name, bool is_global) {
  if (is_global) {
    auto it = glob_map.find(comp_name);
    if (it != glob_map.end()) return (*it).second;
  } else {
    auto it = work_map.find(comp_name);
    if (it != work_map.end()) return (*it).second;
  }
  return nullptr;
}

// Assembly:
pushq %rax
testl %edx, %edx
je 0x40f5c
addq $0xe0, %rdi
jmp 0x40f63
addq $0xa8, %rdi
callq 0x46a24
movq %rax, %rcx
testq %rax, %rax
je 0x40f76
movq 0x28(%rcx), %rax
jmp 0x40f76
testq %rcx, %rcx
jne 0x40f7d
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/convert_ssa.cpp
// Function: ConvertSSA::ProcessResValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ir::Opn*, Value*, SSABasicBlock*)
void ConvertSSA::ProcessResValue(const std::string& comp_name, Opn* opn, Value* val, SSABasicBlock* ssabb) {
  // 如果是全局量就加一条store语句 否则记录映射即可
  MyAssert(opn->type_ == Opn::Type::Var);
  if (0 == opn->scope_id_) {  // 全局变量需要store
    // maintain used_glob_var
    ssabb->GetFunction()->AddUsedGlobVar(dynamic_cast<GlobalVariable*>(val));

    new StoreInst(val, glob_map[comp_name], ssabb);
  } else {
    work_map[comp_name] = val;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x0, (%rdx)
jne 0x41024
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
cmpl $0x0, 0x28(%rdx)
je 0x40fb8
addq $0xa8, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x46b20
movq %rbx, (%rax)
jmp 0x4101a
movq %r8, %r14
movq (%r8), %r13
testq %rbx, %rbx
je 0x40fe0
leaq 0x4e4e6(%rip), %rsi     # 0x8f4b0
leaq 0x4e4ef(%rip), %rdx     # 0x8f4c0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8320
movq %rax, %rsi
jmp 0x40fe2
xorl %esi, %esi
movq %r13, %rdi
callq 0x3567c
movl $0x68, %edi
callq 0x8290
movq %rax, %r13
addq $0xe0, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x46b20
movq (%rax), %rdx
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x443e2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x4efc5(%rip), %rdi     # 0x8fff0
leaq 0x2e136(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x31766(%rip), %rsi     # 0x727a4
movq %rax, %rdi
callq 0x8280
leaq 0x2f373(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x2f, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
movq %rax, %rbx
movl $0x68, %esi
movq %r13, %rdi
callq 0x82a0
movq %rbx, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/convert_ssa.cpp
// Function: ConvertSSA::ProcessGlobalVariable(IRModule*, SSAModule*)
void ConvertSSA::ProcessGlobalVariable(IRModule* irm, SSAModule* ssam) {
#ifdef DEBUG_CONSTRUCT_SSA_PROCESS
  std::cout << "Process All Global Variables Start:" << std::endl;
#endif

  for (auto& [symbol, symbol_item] : irm->global_scope_.symbol_table_) {
    // new glob. record size: int-4 array-4*n. as a i32 pointer.
    auto glob_var = new GlobalVariable(symbol, symbol_item.is_array_ ? symbol_item.width_[0] : 4);
    if (symbol_item.is_const_) {  // NOTE 此时一定是常量数组 原符号表项中的initval失效
      // glob_var->val_.swap(symbol_item.initval_);
      glob_var->val_ = symbol_item.initval_;
    }
    ssam->AddGlobalVariable(glob_var);
    glob_map[symbol] = glob_var;
  }

#ifdef DEBUG_CONSTRUCT_SSA_PROCESS
  std::cout << "Process All Global Variables Finish." << std::endl;
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq 0x40(%rsi), %rax
movq 0x10(%rax), %r13
testq %r13, %r13
je 0x41648
movq %rdi, %r14
addq $0xe0, %r14
leaq 0x4dfbd(%rip), %rbp     # 0x8f560
addq $0x10, %rbp
movl $0x68, %edi
callq 0x8290
movq %rax, %r15
movl $0x4, %ebx
cmpb $0x1, 0x28(%r13)
jne 0x415c6
movq 0x48(%r13), %rax
movl (%rax), %ebx
movl $0x10, %edi
callq 0x8290
leaq 0x8(%r13), %r12
leaq 0x4e2e5(%rip), %rcx     # 0x8f8c0
movq %rcx, (%rax)
movl $0x4, 0x8(%rax)
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x34990
movq %rbp, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
movq $0x0, 0x58(%r15)
movl %ebx, 0x60(%r15)
cmpb $0x1, 0x29(%r13)
jne 0x41621
movq %r15, %rdi
addq $0x48, %rdi
leaq 0x60(%r13), %rsi
callq 0x24b84
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x3522e
movq %r14, %rdi
movq %r12, %rsi
callq 0x46b20
movq %r15, (%rax)
movq (%r13), %r13
testq %r13, %r13
jne 0x415a7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r15, %rdi
callq 0x82a0
movq %rbx, %rdi
callq 0x8540
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/dead_code_eliminate.cpp
// Function: DeadCodeEliminate::Run()
void DeadCodeEliminate::Run() {
  auto m = dynamic_cast<SSAModule*>(*(this->m_));
  MyAssert(nullptr != m);
  DeleteDeadFunc(m);
  FindNoSideEffectFunc(m, no_side_effect_funcs);
  for (auto func : m->GetFuncList()) {
    DeleteDeadInst(func);
    func->MaintainCallFunc();  // 有可能删除call语句
    DeleteDeadStore(func);
  }
  DeleteDeadFunc(m);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4922a
leaq 0x45401(%rip), %rsi     # 0x8e618
leaq 0x46712(%rip), %rdx     # 0x8f930
xorl %ecx, %ecx
callq 0x8320
movq %rax, %r14
jmp 0x4922d
xorl %r14d, %r14d
testq %r14, %r14
je 0x4928c
movq %r14, %rsi
callq 0x492dc
leaq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x49456
leaq 0x40(%r14), %r12
movq 0x40(%r14), %r13
cmpq %r12, %r13
je 0x4927b
movq 0x10(%r13), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x49736
movq %r15, %rdi
callq 0x35452
movq %rbx, %rdi
movq %r15, %rsi
callq 0x498ce
movq (%r13), %r13
jmp 0x4924e
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x492dc
movq 0x46d5d(%rip), %rdi     # 0x8fff0
leaq 0x25ece(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x2952f(%rip), %rsi     # 0x727d5
movq %rax, %rdi
callq 0x8280
leaq 0x2710b(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x10, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/dead_code_eliminate.cpp
// Function: DeadCodeEliminate::DeleteDeadFunc(SSAModule*)
void DeadCodeEliminate::DeleteDeadFunc(SSAModule* m) {
#ifdef DEBUG_DEAD_CODE_ELIMINATE_PROCESS
  std::cout << "Try To Remove Function: " << std::endl;
#endif
  std::unordered_set<SSAFunction*> worklist;
  for (auto func : m->GetFuncList()) {
    if ("main" == func->GetFuncName()) continue;
    worklist.insert(func);
  }
  while (!worklist.empty()) {
    auto func = *worklist.begin();
    worklist.erase(func);
    if (!func->IsCalled()) {
      // 应该把该函数调用的函数加入工作表
      for (auto call_func : func->GetCallFuncList()) {
        if ("main" == call_func->GetFuncName()) continue;
        worklist.insert(call_func);
      }
      // 说明该函数没被调用过 是dead function可以被删除 应该维护的信息全交由Remove函数完成
#ifdef DEBUG_DEAD_CODE_ELIMINATE_PROCESS
      std::cout << "  Remove Function: " << func->GetFuncName() << std::endl;
#endif
      func->Remove();
      delete func;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
leaq 0x50(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq 0x40(%rsi), %rbp
addq $0x40, %rbx
cmpq %rbx, %rbp
je 0x49364
leaq 0x2683c(%rip), %r14     # 0x6fb60
leaq 0x20(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq 0x10(%rbp), %rdi
movq %rdi, 0x8(%rsp)
movq %r14, %rsi
callq 0x8100
testl %eax, %eax
je 0x4935b
movq %r15, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x368b8
movq (%rbp), %rbp
cmpq %rbx, %rbp
jne 0x49333
cmpq $0x0, 0x38(%rsp)
je 0x49423
leaq 0x20(%rsp), %rbx
leaq 0x8(%rsp), %r14
leaq 0x267df(%rip), %r15     # 0x6fb60
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4a072
movq 0x8(%rsp), %rdi
callq 0x356f6
testb %al, %al
jne 0x49417
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rbp
testq %rbp, %rbp
je 0x493ee
movq 0x8(%rbp), %rdi
movq %rdi, 0x18(%rsp)
movq %r15, %rsi
callq 0x8100
testl %eax, %eax
je 0x493e8
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x368b8
movq (%rbp), %rbp
jmp 0x493bb
movq 0x8(%rsp), %rdi
callq 0x35706
movq 0x8(%rsp), %rbp
testq %rbp, %rbp
je 0x49417
movq %rbp, %rdi
callq 0x3581c
movl $0xb8, %esi
movq %rbp, %rdi
callq 0x82a0
cmpq $0x0, 0x38(%rsp)
jne 0x4938b
leaq 0x20(%rsp), %rdi
callq 0x3624c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49440
jmp 0x49440
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3624c
movq %rbx, %rdi
callq 0x8540
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/dead_code_eliminate.cpp
// Function: DeadCodeEliminate::IsSideEffect(SSAInstruction*)
bool DeadCodeEliminate::IsSideEffect(SSAInstruction* inst) {
  if (nullptr == inst) return true;
  // 除callinst外 如果本身无定值[no used]视为有副作用
  if (dynamic_cast<BinaryOperator*>(inst) || dynamic_cast<UnaryOperator*>(inst) || dynamic_cast<LoadInst*>(inst) ||
      dynamic_cast<MovInst*>(inst) || dynamic_cast<PhiInst*>(inst)) {
    return false;
  } else if (auto call_inst = dynamic_cast<CallInst*>(inst)) {
    // 如果call语句无副作用 即便没有定值 也可删除
    auto func_val = dynamic_cast<FunctionValue*>(call_inst->GetOperand(0));
    MyAssert(nullptr != func_val);
    if (no_side_effect_funcs.find(func_val->GetFunction()) != no_side_effect_funcs.end()) return false;
  }
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movb $0x1, %r15b
testq %rsi, %rsi
je 0x49e5f
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x456cc(%rip), %rsi     # 0x8f3f8
leaq 0x458fd(%rip), %rdx     # 0x8f630
xorl %r15d, %r15d
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
jne 0x49e5f
leaq 0x456a8(%rip), %rsi     # 0x8f3f8
leaq 0x45919(%rip), %rdx     # 0x8f670
xorl %r15d, %r15d
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
jne 0x49e5f
leaq 0x45684(%rip), %rsi     # 0x8f3f8
leaq 0x45a35(%rip), %rdx     # 0x8f7b0
xorl %r15d, %r15d
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
jne 0x49e5f
leaq 0x45660(%rip), %rsi     # 0x8f3f8
leaq 0x45a91(%rip), %rdx     # 0x8f830
xorl %r15d, %r15d
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
jne 0x49e5f
leaq 0x4563c(%rip), %rsi     # 0x8f3f8
leaq 0x45aad(%rip), %rdx     # 0x8f870
xorl %r15d, %r15d
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
jne 0x49e5f
leaq 0x45618(%rip), %rsi     # 0x8f3f8
leaq 0x45909(%rip), %rdx     # 0x8f6f0
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
je 0x49e5c
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
callq 0x33480
testq %rax, %rax
je 0x49e23
leaq 0x456a1(%rip), %rsi     # 0x8f4b0
leaq 0x456f2(%rip), %rdx     # 0x8f508
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x8320
movq %rax, %r14
testq %r14, %r14
je 0x49e6c
leaq 0x38(%rbx), %rdi
movq 0x60(%r14), %rcx
leaq 0x8(%rsp), %r8
movq %rcx, (%r8)
movq %rcx, %rax
xorl %edx, %edx
divq 0x40(%rbx)
movq %rdx, %rsi
movq %r8, %rdx
callq 0x36708
testq %rax, %rax
je 0x49e5c
cmpq $0x0, (%rax)
je 0x49e5c
xorl %r15d, %r15d
jmp 0x49e5f
movb $0x1, %r15b
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x4617d(%rip), %rdi     # 0x8fff0
leaq 0x252ee(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x2894f(%rip), %rsi     # 0x727d5
movq %rax, %rdi
callq 0x8280
leaq 0x2652b(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x44, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/dead_code_eliminate.cpp
// Function: DeadCodeEliminate::RemoveFromNoSideEffectFuncs(SSAFunction*, std::unordered_set<SSAFunction*, std::hash<SSAFunction*>, std::equal_to<SSAFunction*>, std::allocator<SSAFunction*>>&)
void DeadCodeEliminate::RemoveFromNoSideEffectFuncs(SSAFunction* func,
                                                    std::unordered_set<SSAFunction*>& no_side_effect_funcs) {
  // 如果已经删了说明已经访问过直接返回
  if (no_side_effect_funcs.find(func) == no_side_effect_funcs.end()) return;
  // 先把func删了
  no_side_effect_funcs.erase(func);
  // 再把func的每个caller都删了
  for (auto use : func->GetValue()->GetUses()) {
    auto call_inst = dynamic_cast<CallInst*>(use->GetUser());
    MyAssert(nullptr != call_inst);
    auto caller = call_inst->GetParent()->GetFunction();
    // no_side_effect_funcs.erase(caller);
    RemoveFromNoSideEffectFuncs(caller, no_side_effect_funcs);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq (%rsi), %rsi
movq 0x8(%rbx), %r8
xorl %r10d, %r10d
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movq (%rsi,%rdx,8), %rax
testq %rax, %rax
je 0x49f2a
movq (%rax), %r9
movq %rax, %r10
cmpq %rdi, 0x8(%r9)
je 0x49f2a
movq %rdx, %rcx
movq %r9, %r11
movq (%r9), %r9
testq %r9, %r9
je 0x49f27
movq 0x8(%r9), %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %r10d
cmpq %rcx, %rdx
jne 0x49f2a
movq %r11, %r10
cmpq %rdi, %rsi
jne 0x49efb
jmp 0x49f2a
xorl %r10d, %r10d
testq %r10, %r10
je 0x49fa3
cmpq $0x0, (%r10)
je 0x49fa3
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4a072
movq (%r14), %rax
movq 0x28(%rax), %r12
movq 0x10(%r12), %r13
addq $0x10, %r12
cmpq %r12, %r13
je 0x49fa3
leaq 0x4568f(%rip), %r14     # 0x8f5f0
leaq 0x45788(%rip), %r15     # 0x8f6f0
movq 0x10(%r13), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x49f84
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x8320
jmp 0x49f86
xorl %eax, %eax
testq %rax, %rax
je 0x49fb1
movq 0x60(%rax), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x49ebc
movq (%r13), %r13
cmpq %r12, %r13
jne 0x49f68
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x46038(%rip), %rdi     # 0x8fff0
leaq 0x251a9(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x2880a(%rip), %rsi     # 0x727d5
movq %rax, %rdi
callq 0x8280
leaq 0x263e6(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x75, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/dominant.cpp
// Function: ComputeDominance::DFS(IRBasicBlock*, IRBasicBlock*)
void ComputeDominance::DFS(BB* p, BB* n) {
  if (dfnum.find(n) != dfnum.end()) return;
  dfnum.insert({n, N});
  vertex[N] = n;
  parent.insert({n, p});  // NOTE: parent[root]=nullptr
  ++N;
  for (auto succ : n->succ_) {
    DFS(n, succ);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x50(%rdi), %rsi
movq 0x58(%rdi), %rdi
xorl %r9d, %r9d
movq %rdx, %rax
xorl %edx, %edx
divq %rdi
movq (%rsi,%rdx,8), %rax
testq %rax, %rax
je 0x4b26e
movq (%rax), %r8
movq %rax, %r9
cmpq %rbx, 0x8(%r8)
je 0x4b26e
movq %rdx, %rcx
movq %r8, %r10
movq (%r8), %r8
testq %r8, %r8
je 0x4b26b
movq 0x8(%r8), %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movl $0x0, %r9d
cmpq %rcx, %rdx
jne 0x4b26e
movq %r10, %r9
cmpq %rbx, %rsi
jne 0x4b23f
jmp 0x4b26e
xorl %r9d, %r9d
testq %r9, %r9
je 0x4b285
cmpq $0x0, (%r9)
je 0x4b285
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x50(%r14), %rdi
leaq 0x8(%rsp), %r12
movq %rbx, (%r12)
movl 0x34(%r14), %eax
movl %eax, 0x8(%r12)
movq %r12, %rsi
callq 0x4bca8
movslq 0x34(%r14), %rax
movq 0x38(%r14), %rcx
movq %rbx, (%rcx,%rax,8)
leaq 0x88(%r14), %rdi
movq %rbx, (%r12)
movq %r15, 0x8(%r12)
leaq 0x8(%rsp), %rsi
callq 0x4bf4a
incl 0x34(%r14)
movq 0x40(%rbx), %r15
movq 0x48(%rbx), %r12
cmpq %r12, %r15
je 0x4b279
movq (%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4b200
addq $0x8, %r15
jmp 0x4b2d5
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/dominant.cpp
// Function: ComputeDominance::ResetTempInfo(IRFunction*)
void ComputeDominance::ResetTempInfo(IRFunction* f) {
  // 初始化数据 9
  vertex.clear();
  dfnum.clear();
  parent.clear();
  semi.clear();
  // idom.clear();
  bucket.clear();
  ancestor.clear();
  samedom.clear();
  best.clear();
  vertex.resize(f->bb_list_.size());
  N = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movq 0x38(%rdi), %rax
cmpq %rax, 0x40(%rdi)
je 0x4b5b9
movq %rax, 0x40(%rbx)
leaq 0x50(%rbx), %rdi
callq 0x4c384
leaq 0x88(%rbx), %rdi
callq 0x4c3ce
leaq 0x130(%rbx), %rdi
callq 0x4c3ce
leaq 0x1a0(%rbx), %rdi
callq 0x4c418
leaq 0xc0(%rbx), %rdi
callq 0x4c3ce
leaq 0x168(%rbx), %rdi
callq 0x4c3ce
leaq 0xf8(%rbx), %rdi
callq 0x4c3ce
movq 0x38(%r15), %rsi
subq 0x30(%r15), %rsi
sarq $0x3, %rsi
movq %r14, %rdi
callq 0x4bc2e
movl $0x0, 0x34(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/dominant.cpp
// Function: ComputeDominance::ComputeDomFrontier(IRBasicBlock*)
void ComputeDominance::ComputeDomFrontier(ComputeDominance::BB* bb) {
  for (auto succ : bb->succ_) {
    if (succ->idom_ != bb) {  // bb一定不是该succ的必经结点
      bb->df_.insert(succ);
    }
  }
  for (auto child : bb->doms_) {
    ComputeDomFrontier(child);
    for (auto child_df : child->df_) {
      if (!child_df->IsByDom(bb) || child_df == bb) {  // bb不是child_df的严格必经结点
        bb->df_.insert(child_df);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, 0x20(%rsp)
movq 0x40(%rsi), %r14
movq 0x48(%rsi), %rbp
cmpq %rbp, %r14
je 0x4bacd
leaq 0x270(%rbx), %r15
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq (%r14), %rax
movq %rax, 0x8(%rsp)
cmpq %rbx, 0x250(%rax)
je 0x4bac4
movq %r15, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4875a
addq $0x8, %r14
cmpq %rbp, %r14
jne 0x4baa0
movq 0x258(%rbx), %r14
movq 0x260(%rbx), %rax
movq %rax, 0x18(%rsp)
cmpq %rax, %r14
je 0x4bb52
leaq 0x270(%rbx), %r15
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq (%r14), %rbp
movq 0x20(%rsp), %rdi
movq %rbp, %rsi
callq 0x4ba6c
movq 0x280(%rbp), %rbp
testq %rbp, %rbp
je 0x4bb47
movq 0x8(%rbp), %rdi
movq %rdi, 0x8(%rsp)
movq %rbx, %rsi
callq 0x2b944
testb %al, %al
je 0x4bb2e
cmpq %rbx, 0x8(%rsp)
jne 0x4bb41
movq %r15, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4875a
movq (%rbp), %rbp
jmp 0x4bb0d
addq $0x8, %r14
cmpq 0x18(%rsp), %r14
jne 0x4baf6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/dominant.cpp
// Function: ComputeDominance::Run()
void ComputeDominance::Run() {
  auto m = dynamic_cast<IRModule*>(*(this->m_));
  MyAssert(nullptr != m);
  for (auto func : m->func_list_) {
    ResetTempInfo(func);
    ComputeIDomInfo(func);                       // 填写func中每个bb的idom和doms信息
    ComputeDomFrontier(func->bb_list_.front());  // 填写func中每个bb的df信息
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4bb90
leaq 0x42a98(%rip), %rsi     # 0x8e618
leaq 0x434f1(%rip), %rdx     # 0x8f078
xorl %ecx, %ecx
callq 0x8320
jmp 0x4bb92
xorl %eax, %eax
testq %rax, %rax
je 0x4bbde
movq 0x28(%rax), %r15
movq 0x30(%rax), %r12
cmpq %r12, %r15
je 0x4bbd2
movq (%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b59c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b62c
movq 0x30(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4ba6c
addq $0x8, %r15
jmp 0x4bb9f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x4440b(%rip), %rdi     # 0x8fff0
leaq 0x2357c(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x26c2a(%rip), %rsi     # 0x72822
movq %rax, %rdi
callq 0x8280
leaq 0x247b9(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x83, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/generate_arm_from_ssa.cpp
// Function: GenerateArmFromSSA::ResolveValue2Operand2(ArmBasicBlock*, Value*)
Operand2* GenerateArmFromSSA::ResolveValue2Operand2(ArmBasicBlock* armbb, Value* val) {
  if (auto src_val = dynamic_cast<ConstantInt*>(val)) {
    return ResolveImm2Operand2(armbb, src_val->GetImm());
  } else {
    return new Operand2(ResolveValue2Reg(armbb, val));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x4e092
leaq 0x41431(%rip), %rsi     # 0x8f4b0
leaq 0x41452(%rip), %rdx     # 0x8f4d8
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
jmp 0x4e094
xorl %eax, %eax
testq %rax, %rax
je 0x4e0b4
movl 0x48(%rax), %edx
movq %r15, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4cd8a
movl $0x18, %edi
callq 0x8290
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4d592
movb $0x0, (%r12)
movl $0x0, 0x4(%r12)
movq %rax, 0x8(%r12)
movq $0x0, 0x10(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r12, %rdi
callq 0x82a0
movq %rbx, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/generate_arm_from_ssa.cpp
// Function: GenerateArmFromSSA::AddEpilogue(ArmFunction*)
void GenerateArmFromSSA::AddEpilogue(ArmFunction* func) {
  // add sp, sp, #stack_size 之后应该修改为栈大小 记录在sp_fixup里
  auto op2 = ResolveImm2Operand2(epilogue, 0, true);
  new BinaryInst(BiOp::ADD, machine_regs[ArmReg::sp], machine_regs[ArmReg::sp], op2, epilogue);
  MyAssert(!op2->is_imm_);

  // pop {pc} NOTE: same as bx lr
  auto pop_inst = new PushPop(PushPop::OpKind::POP, epilogue);
  pop_inst->reg_list_.push_back(machine_regs[ArmReg::pc]);

  // all pred bbs are already maintained
  func->bb_list_.push_back(epilogue);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x110(%rdi), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x4cd8a
movq %rax, %r12
movl $0x38, %edi
callq 0x8290
movq %rax, %r15
movq 0x38(%r14), %rax
movq 0x110(%r14), %rsi
movq 0x68(%rax), %r13
movq %r15, %rdi
movl $0x1, %edx
callq 0xa6a8
leaq 0x40025(%rip), %rax     # 0x8e460
leaq 0x10(%rax), %rcx
movq %rcx, (%r15)
movl $0x0, 0x14(%r15)
movb $0x0, 0x18(%r15)
movq %r13, 0x20(%r15)
movq %r13, 0x28(%r15)
movq %r12, 0x30(%r15)
movq %r15, %rdi
callq *0x28(%rax)
cmpb $0x1, (%r12)
je 0x4e51d
leaq 0x110(%r14), %r15
movl $0x30, %edi
callq 0x8290
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0xa6a8
leaq 0x3ff81(%rip), %rax     # 0x8e418
addq $0x10, %rax
movq %rax, (%r12)
movl $0x1, 0x14(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
movq $0x0, 0x28(%r12)
movq 0x38(%r14), %rdx
addq $0x78, %rdx
movq 0x20(%r12), %rsi
testq %rsi, %rsi
je 0x4e4da
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x20(%r12)
jmp 0x4e4e6
addq $0x18, %r12
movq %r12, %rdi
callq 0x3d380
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x4e505
movq (%r15), %rax
movq %rax, (%rsi)
addq $0x8, 0x40(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
addq $0x38, %rbx
movq %rbx, %rdi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x51cf6
movq 0x41acc(%rip), %rdi     # 0x8fff0
leaq 0x20c3d(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x24359(%rip), %rsi     # 0x72890
movq %rax, %rdi
callq 0x8280
leaq 0x21e7a(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x16f, %esi            # imm = 0x16F
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
movq %rax, %rbx
movl $0x30, %esi
movq %r12, %rdi
jmp 0x4e585
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x82a0
movq %rbx, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/generate_arm_from_ssa.cpp
// Function: GenerateArmFromSSA::ResetFuncData()
void GenerateArmFromSSA::ResetFuncData() {
  machine_regs.clear();
  for (int i = 0; i < 16; ++i) {
    machine_regs.push_back(new Reg(i));
  }
  this->virtual_reg_id = 16;
  this->var_map.clear();
  this->stack_size = 0;
  this->sp_arg_fixup.clear();
  this->sp_fixup.clear();
  this->prologue = nullptr;
  this->epilogue = nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rax
cmpq %rax, 0x40(%rdi)
je 0x4e5aa
movq %rax, 0x40(%rbx)
leaq 0x38(%rbx), %r14
xorl %ebp, %ebp
movq %rsp, %r15
movl $0x40, %edi
callq 0x8290
leaq 0x30(%rax), %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movl %ebp, 0x38(%rax)
movq %rax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3d4a0
incl %ebp
cmpl $0x10, %ebp
jne 0x4e5b3
movl $0x10, 0x50(%rbx)
leaq 0x58(%rbx), %rdi
callq 0x51422
movl $0x0, 0x90(%rbx)
leaq 0x98(%rbx), %rdi
callq 0x3e47e
leaq 0xd0(%rbx), %rdi
callq 0x3e47e
xorps %xmm0, %xmm0
movups %xmm0, 0x108(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/generate_arm_from_ssa.cpp
// Function: GenerateArmFromSSA::Run()
void GenerateArmFromSSA::Run() {
  auto m = dynamic_cast<SSAModule*>(*(this->m_));
  MyAssert(nullptr != m);
  auto arm_m = this->GenCode(m);
  *(this->m_) = static_cast<Module*>(arm_m);
  delete m;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x50f83
leaq 0x3d6a8(%rip), %rsi     # 0x8e618
leaq 0x3e9b9(%rip), %rdx     # 0x8f930
xorl %ecx, %ecx
callq 0x8320
movq %rax, %r14
jmp 0x50f86
xorl %r14d, %r14d
testq %r14, %r14
je 0x50fad
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4eb48
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x8(%rax)
movq 0x3f03c(%rip), %rdi     # 0x8fff0
leaq 0x1e1ad(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x218c9(%rip), %rsi     # 0x72890
movq %rax, %rdi
callq 0x8280
leaq 0x1f3ea(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x336, %esi            # imm = 0x336
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
nop