LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x408b2
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
cmpl $0x0, 0x28(%rdx)
je 0x40846
addq $0xa8, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x463ba
movq %rbx, (%rax)
jmp 0x408a8
movq %r8, %r14
movq (%r8), %r13
testq %rbx, %rbx
je 0x4086e
leaq 0x4dc28(%rip), %rsi     # 0x8e480
leaq 0x4dc31(%rip), %rdx     # 0x8e490
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8320
movq %rax, %rsi
jmp 0x40870
xorl %esi, %esi
movq %r13, %rdi
callq 0x357dc
movl $0x68, %edi
callq 0x8290
movq %rax, %r13
addq $0xe0, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x463ba
movq (%rax), %rdx
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x43c4e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x4e72f(%rip), %rdi     # 0x8efe8
leaq 0x2d8a8(%rip), %rsi     # 0x6e168
callq 0x8280
leaq 0x30edc(%rip), %rsi     # 0x717a8
movq %rax, %rdi
callq 0x8280
leaq 0x2eae5(%rip), %rsi     # 0x6f3c0
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_O3/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 0x40ec4
movq %rdi, %r14
addq $0xe0, %r14
leaq 0x4d711(%rip), %rbp     # 0x8e530
addq $0x10, %rbp
movl $0x68, %edi
callq 0x8290
movq %rax, %r15
movl $0x4, %ebx
cmpb $0x1, 0x28(%r13)
jne 0x40e42
movq 0x48(%r13), %rax
movl (%rax), %ebx
movl $0x10, %edi
callq 0x8290
leaq 0x8(%r13), %r12
leaq 0x4da39(%rip), %rcx     # 0x8e890
movq %rcx, (%rax)
movl $0x4, 0x8(%rax)
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x34ade
movq %rbp, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
movq $0x0, 0x58(%r15)
movl %ebx, 0x60(%r15)
cmpb $0x1, 0x29(%r13)
jne 0x40e9d
movq %r15, %rdi
addq $0x48, %rdi
leaq 0x60(%r13), %rsi
callq 0x25242
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x3538a
movq %r14, %rdi
movq %r12, %rsi
callq 0x463ba
movq %r15, (%rax)
movq (%r13), %r13
testq %r13, %r13
jne 0x40e23
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_O3/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 0x489da
leaq 0x44ce1(%rip), %rsi     # 0x8d648
leaq 0x45f92(%rip), %rdx     # 0x8e900
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
je 0x489da
movq %rax, %r14
movq %rax, %rsi
callq 0x48a2a
leaq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x48ba6
movq %r14, %r12
addq $0x40, %r12
movq 0x40(%r14), %r13
cmpq %r12, %r13
je 0x489c9
movq 0x10(%r13), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x48dd2
movq %r15, %rdi
callq 0x355ba
movq %rbx, %rdi
movq %r15, %rsi
callq 0x48f6c
movq (%r13), %r13
jmp 0x4899c
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x48a2a
movq 0x46607(%rip), %rdi     # 0x8efe8
leaq 0x25780(%rip), %rsi     # 0x6e168
callq 0x8280
leaq 0x28de5(%rip), %rsi     # 0x717d9
movq %rax, %rdi
callq 0x8280
leaq 0x269bd(%rip), %rsi     # 0x6f3c0
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_O3/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, %r14
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, %r14
cmpq %r14, %rbp
je 0x48b73
leaq 0x260ea(%rip), %r15     # 0x6eb60
leaq 0x20(%rsp), %rbx
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq 0x10(%rbp), %rdi
movq %rdi, 0x8(%rsp)
movq %r15, %rsi
callq 0x8100
testl %eax, %eax
je 0x48aad
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x369b0
movq (%rbp), %rbp
cmpq %r14, %rbp
jne 0x48a85
cmpq $0x0, 0x38(%rsp)
je 0x48b73
leaq 0x8(%rsp), %r14
leaq 0x26092(%rip), %r15     # 0x6eb60
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 0x49670
movq 0x8(%rsp), %rdi
callq 0x35856
testb %al, %al
jne 0x48b67
movq 0x8(%rsp), %rdi
movq 0x58(%rdi), %rbp
testq %rbp, %rbp
je 0x48b43
movq 0x8(%rbp), %rdi
movq %rdi, 0x18(%rsp)
movq %r15, %rsi
callq 0x8100
testl %eax, %eax
je 0x48b35
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x369b0
movq (%rbp), %rbp
testq %rbp, %rbp
jne 0x48b0d
movq 0x8(%rsp), %rdi
callq 0x35866
movq 0x8(%rsp), %rbp
testq %rbp, %rbp
je 0x48b5a
movq %rbp, %rdi
callq 0x3597c
movl $0xb8, %esi
movq %rbp, %rdi
callq 0x82a0
cmpq $0x0, 0x38(%rsp)
jne 0x48ad8
leaq 0x20(%rsp), %rdi
callq 0x363b4
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48b90
jmp 0x48b90
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x363b4
movq %rbx, %rdi
callq 0x8540
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x494b5
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4502a(%rip), %rsi     # 0x8e3c8
leaq 0x4525b(%rip), %rdx     # 0x8e600
xorl %r15d, %r15d
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
jne 0x494b5
leaq 0x45006(%rip), %rsi     # 0x8e3c8
leaq 0x45277(%rip), %rdx     # 0x8e640
xorl %r15d, %r15d
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
jne 0x494b5
leaq 0x44fe2(%rip), %rsi     # 0x8e3c8
leaq 0x45393(%rip), %rdx     # 0x8e780
xorl %r15d, %r15d
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
jne 0x494b5
leaq 0x44fbe(%rip), %rsi     # 0x8e3c8
leaq 0x453ef(%rip), %rdx     # 0x8e800
xorl %r15d, %r15d
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
jne 0x494b5
leaq 0x44f9a(%rip), %rsi     # 0x8e3c8
leaq 0x4540b(%rip), %rdx     # 0x8e840
xorl %r15d, %r15d
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
jne 0x494b5
leaq 0x44f7a(%rip), %rsi     # 0x8e3c8
leaq 0x4526b(%rip), %rdx     # 0x8e6c0
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
je 0x494b2
movq %rax, %rdi
xorl %esi, %esi
callq 0x335d4
testq %rax, %rax
je 0x494c2
leaq 0x45006(%rip), %rsi     # 0x8e480
leaq 0x45057(%rip), %rdx     # 0x8e4d8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
je 0x494c2
addq $0x38, %rbx
movq 0x60(%rax), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x49760
testq %rax, %rax
je 0x494b2
xorl %r15d, %r15d
jmp 0x494b5
movb $0x1, %r15b
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x45b1f(%rip), %rdi     # 0x8efe8
leaq 0x24c98(%rip), %rsi     # 0x6e168
callq 0x8280
leaq 0x282fd(%rip), %rsi     # 0x717d9
movq %rax, %rdi
callq 0x8280
leaq 0x25ed5(%rip), %rsi     # 0x6f3c0
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_O3/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
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq %rbx, %rdi
callq 0x49760
testq %rax, %rax
je 0x495a1
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49670
movq (%r14), %rax
movq 0x28(%rax), %r12
movq 0x10(%r12), %r13
addq $0x10, %r12
cmpq %r12, %r13
je 0x495a1
leaq 0x4505d(%rip), %r14     # 0x8e5c0
leaq 0x45156(%rip), %r15     # 0x8e6c0
movq 0x10(%r13), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x495af
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
je 0x495af
movq 0x60(%rax), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x49512
movq (%r13), %r13
cmpq %r12, %r13
jne 0x4956a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x45a32(%rip), %rdi     # 0x8efe8
leaq 0x24bab(%rip), %rsi     # 0x6e168
callq 0x8280
leaq 0x28210(%rip), %rsi     # 0x717d9
movq %rax, %rdi
callq 0x8280
leaq 0x25de8(%rip), %rsi     # 0x6f3c0
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_O3/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 %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %rdx, (%rsi)
leaq 0x50(%rdi), %r15
movq %r15, %rdi
callq 0x4b142
testq %rax, %rax
je 0x4a87c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%rsp), %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movl 0x34(%rbx), %eax
movl %eax, 0x8(%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4b19e
movq (%rsp), %rax
movslq 0x34(%rbx), %rcx
movq 0x38(%rbx), %rdx
movq %rax, (%rdx,%rcx,8)
leaq 0x88(%rbx), %rdi
movq %rax, (%r12)
movq %r14, 0x8(%r12)
leaq 0x8(%rsp), %rsi
callq 0x4b430
incl 0x34(%rbx)
movq (%rsp), %rax
movq 0x40(%rax), %r14
movq 0x48(%rax), %r15
cmpq %r15, %r14
je 0x4a870
movq (%r14), %rdx
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x4a848
addq $0x8, %r14
jmp 0x4a8d5
nop
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/dominant.cpp
// Function: ComputeDominance::AncestorWithLowestSemi(IRBasicBlock*)
ComputeDominance::BB* ComputeDominance::AncestorWithLowestSemi(ComputeDominance::BB* v) {
  MyAssert(ancestor.find(v) != ancestor.end());
  // 从a到v(included)这段已经算过了 存在best[v]里 compute min(dfnum[semi[y]])
  auto a = ancestor[v];
  MyAssert(nullptr != a);  // 不会出现a为空的情况 根节点不会被链入到ancestor中
  if (ancestor.find(a) != ancestor.end()) {
    // 把当前生成树森林中v的最小的祖先到a(included)这段也算了 存在best[a]里 即b
    auto b = AncestorWithLowestSemi(a);
    // 更新 使更新后从ancestor[a]到v(included)这段都算过 存在best[v]里
    ancestor[v] = ancestor[a];
    if (dfnum[semi[b]] < dfnum[semi[best[v]]]) {
      best[v] = b;
    }
  }
  return best[v];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0xc0(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x4b6c2
testq %rax, %rax
je 0x4aa60
movq %rsp, %rsi
movq %r14, %rdi
callq 0x4b71e
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x4aa9b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4b6c2
testq %rax, %rax
je 0x4aa3c
leaq 0x8(%rsp), %r15
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x4a93c
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b71e
movq (%rax), %r13
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b71e
movq %r13, (%rax)
leaq 0x50(%rbx), %r13
leaq 0x130(%rbx), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4b71e
movq %r13, %rdi
movq %rax, %rsi
callq 0x4b7d6
movl (%rax), %r12d
leaq 0xf8(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b71e
movq %rbp, %rdi
movq %rax, %rsi
callq 0x4b71e
movq %r13, %rdi
movq %rax, %rsi
callq 0x4b7d6
cmpl (%rax), %r12d
jge 0x4aa3c
movq 0x10(%rsp), %r15
movq %rsp, %rsi
movq %r14, %rdi
callq 0x4b71e
movq %r15, (%rax)
addq $0xf8, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4b71e
movq (%rax), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x44581(%rip), %rdi     # 0x8efe8
leaq 0x236fa(%rip), %rsi     # 0x6e168
callq 0x8280
leaq 0x26dac(%rip), %rsi     # 0x71826
movq %rax, %rdi
callq 0x8280
leaq 0x24937(%rip), %rsi     # 0x6f3c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x17, %esi
jmp 0x4aad4
movq 0x44546(%rip), %rdi     # 0x8efe8
leaq 0x236bf(%rip), %rsi     # 0x6e168
callq 0x8280
leaq 0x26d71(%rip), %rsi     # 0x71826
movq %rax, %rdi
callq 0x8280
leaq 0x248fc(%rip), %rsi     # 0x6f3c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x1a, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4ab09
movq %rax, 0x40(%rbx)
leaq 0x50(%rbx), %rdi
callq 0x4b894
leaq 0x88(%rbx), %rdi
callq 0x4b8de
leaq 0x130(%rbx), %rdi
callq 0x4b8de
leaq 0x1a0(%rbx), %rdi
callq 0x4b928
leaq 0xc0(%rbx), %rdi
callq 0x4b8de
leaq 0x168(%rbx), %rdi
callq 0x4b8de
leaq 0xf8(%rbx), %rdi
callq 0x4b8de
movq 0x38(%r15), %rsi
subq 0x30(%r15), %rsi
sarq $0x3, %rsi
movq %r14, %rdi
callq 0x4b110
movl $0x0, 0x34(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4afb3
leaq 0x270(%rbx), %r15
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq (%r14), %rax
movq %rax, 0x8(%rsp)
cmpq %rbx, 0x250(%rax)
je 0x4afaa
movq %r15, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x47f24
addq $0x8, %r14
cmpq %rbp, %r14
jne 0x4af86
movq 0x258(%rbx), %r14
movq 0x260(%rbx), %rax
movq %rax, 0x18(%rsp)
cmpq %rax, %r14
je 0x4b038
leaq 0x270(%rbx), %r15
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq (%r14), %rbp
movq 0x20(%rsp), %rdi
movq %rbp, %rsi
callq 0x4af52
movq 0x280(%rbp), %rbp
testq %rbp, %rbp
je 0x4b02d
movq 0x8(%rbp), %rdi
movq %rdi, 0x8(%rsp)
movq %rbx, %rsi
callq 0x2be72
testb %al, %al
je 0x4b014
cmpq %rbx, 0x8(%rsp)
jne 0x4b027
movq %r15, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x47f24
movq (%rbp), %rbp
jmp 0x4aff3
addq $0x8, %r14
cmpq 0x18(%rsp), %r14
jne 0x4afdc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4b0c0
leaq 0x425e2(%rip), %rsi     # 0x8d648
leaq 0x43003(%rip), %rdx     # 0x8e070
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
je 0x4b0c0
movq 0x28(%rax), %r15
movq 0x30(%rax), %r12
cmpq %r12, %r15
je 0x4b0b4
movq (%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4aaec
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ab7c
movq 0x30(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4af52
addq $0x8, %r15
jmp 0x4b081
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x43f21(%rip), %rdi     # 0x8efe8
leaq 0x2309a(%rip), %rsi     # 0x6e168
callq 0x8280
leaq 0x2674c(%rip), %rsi     # 0x71826
movq %rax, %rdi
callq 0x8280
leaq 0x242d7(%rip), %rsi     # 0x6f3c0
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_O3/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 0x4d458
leaq 0x41059(%rip), %rsi     # 0x8e480
leaq 0x4107a(%rip), %rdx     # 0x8e4a8
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
je 0x4d458
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 0x4c21a
movl $0x18, %edi
callq 0x8290
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4ca18
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_O3/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 0x4c21a
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 0xa41e
leaq 0x3fcc7(%rip), %rax     # 0x8d490
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 0x4d895
leaq 0x110(%r14), %r15
movl $0x30, %edi
callq 0x8290
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0xa41e
leaq 0x3fc23(%rip), %rax     # 0x8d448
addq $0x10, %rax
movq %rax, (%r12)
movl $0x1, 0x14(%r12)
movq %r12, %rdi
addq $0x18, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
movq $0x0, 0x28(%r12)
movq 0x38(%r14), %rdx
addq $0x78, %rdx
xorl %esi, %esi
callq 0x3ce18
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x4d87d
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 0x51066
movq 0x4174c(%rip), %rdi     # 0x8efe8
leaq 0x208c5(%rip), %rsi     # 0x6e168
callq 0x8280
leaq 0x23fe5(%rip), %rsi     # 0x71894
movq %rax, %rdi
callq 0x8280
leaq 0x21b02(%rip), %rsi     # 0x6f3c0
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 0x4d8fd
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x82a0
movq %rbx, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4d922
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 0x3cf38
incl %ebp
cmpl $0x10, %ebp
jne 0x4d92b
movl $0x10, 0x50(%rbx)
leaq 0x58(%rbx), %rdi
callq 0x5073c
movl $0x0, 0x90(%rbx)
leaq 0x98(%rbx), %rdi
callq 0x3dde2
leaq 0xd0(%rbx), %rdi
callq 0x3dde2
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_O3/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 0x502bc
leaq 0x3d3c4(%rip), %rsi     # 0x8d648
leaq 0x3e675(%rip), %rdx     # 0x8e900
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
je 0x502bc
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4debc
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x8(%rax)
movq 0x3ed25(%rip), %rdi     # 0x8efe8
leaq 0x1de9e(%rip), %rsi     # 0x6e168
callq 0x8280
leaq 0x215be(%rip), %rsi     # 0x71894
movq %rax, %rdi
callq 0x8280
leaq 0x1f0db(%rip), %rsi     # 0x6f3c0
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
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/global_value_numbering.cpp
// Function: GlobalValueNumbering::DFS(std::vector<SSABasicBlock*, std::allocator<SSABasicBlock*>>&, std::unordered_set<SSABasicBlock*, std::hash<SSABasicBlock*>, std::equal_to<SSABasicBlock*>, std::allocator<SSABasicBlock*>>&, SSABasicBlock*, bool)
void GlobalValueNumbering::DFS(std::vector<SSABasicBlock*>& po, std::unordered_set<SSABasicBlock*>& vis,
                               SSABasicBlock* bb, bool succ) {
  MyAssert(nullptr != bb);
  if (vis.find(bb) == vis.end()) {
    vis.insert(bb);
    for (auto next_bb : (succ ? bb->GetSuccBB() : bb->GetPredBB())) {
      MyAssert(nullptr != next_bb);
      DFS(po, vis, next_bb);
    }
    po.push_back(bb);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, (%rsp)
testq %rdx, %rdx
je 0x53694
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x54a74
testq %rax, %rax
jne 0x53637
leaq 0x8(%rsp), %rdx
movq %r14, (%rdx)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x36494
testb %bpl, %bpl
movl $0x58, %eax
movl $0x40, %ecx
cmovneq %rax, %rcx
movq (%r15), %rax
leaq (%rax,%rcx), %r15
movq (%rax,%rcx), %r12
cmpq %r15, %r12
je 0x53614
movq 0x10(%r12), %rdx
testq %rdx, %rdx
je 0x53644
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x5358c
movq (%r12), %r12
jmp 0x535ef
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5362c
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x53637
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x457e6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3b99d(%rip), %rdi     # 0x8efe8
leaq 0x1ab16(%rip), %rsi     # 0x6e168
callq 0x8280
leaq 0x1e2bd(%rip), %rsi     # 0x7191b
movq %rax, %rdi
callq 0x8280
leaq 0x1bd53(%rip), %rsi     # 0x6f3c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x183, %esi            # imm = 0x183
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
movq 0x3b94d(%rip), %rdi     # 0x8efe8
leaq 0x1aac6(%rip), %rsi     # 0x6e168
callq 0x8280
leaq 0x1e26d(%rip), %rsi     # 0x7191b
movq %rax, %rdi
callq 0x8280
leaq 0x1bd03(%rip), %rsi     # 0x6f3c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x17f, %esi            # imm = 0x17F
jmp 0x5367d
nop
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/global_value_numbering.cpp
// Function: GlobalValueNumbering::ComputeRPO(SSAFunction*)
std::vector<SSABasicBlock*> GlobalValueNumbering::ComputeRPO(SSAFunction* func) {
  std::vector<SSABasicBlock*> po;
  std::unordered_set<SSABasicBlock*> vis;
  if (func->GetBBList().size() > 0) DFS(po, vis, func->GetBBList().front());
  std::reverse(po.begin(), po.end());
  return po;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x30(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
cmpq $0x0, 0x40(%rsi)
je 0x5376a
movq 0x30(%rsi), %rax
movq 0x10(%rax), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x5358c
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
setne %dl
addq $-0x8, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x5376a
addq $0x8, %rax
movq -0x8(%rax), %rdx
movq (%rcx), %rsi
movq %rsi, -0x8(%rax)
movq %rdx, (%rcx)
addq $-0x8, %rcx
leaq 0x8(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x5374c
movq %rsp, %rdi
callq 0x36424
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x36424
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5379c
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x82a0
movq %r14, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/instruction_combining.cpp
// Function: isSameOpn(ir::Opn, ir::Opn)
static bool isSameOpn(ir::Opn opn1, ir::Opn opn2) {
  if (opn1.type_ == opn2.type_ && opn1.type_ == ir::Opn::Type::Var) {
    if (opn1.name_ == opn2.name_ && opn1.scope_id_ == opn2.scope_id_) {
      return true;
    }
    return false;
  } else if (opn1.type_ == opn2.type_ && opn1.type_ == ir::Opn::Type::Array) {
    //先不考虑数组的情况，这里什么也没有
  } else if (opn1.type_ == opn2.type_ && opn1.type_ == ir::Opn::Type::Imm) {
    return opn1.imm_num_ == opn2.imm_num_;
  }

  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
movl (%rsi), %ecx
movl %ecx, %edx
orl %eax, %edx
jne 0x57f76
movq 0x10(%r14), %rdx
cmpq 0x10(%rbx), %rdx
jne 0x57f8b
testq %rdx, %rdx
je 0x57f69
movq 0x8(%rbx), %rsi
movq 0x8(%r14), %rdi
callq 0x82b0
testl %eax, %eax
jne 0x57f8b
movl 0x28(%r14), %ecx
movb $0x1, %al
cmpl 0x28(%rbx), %ecx
jne 0x57f8b
jmp 0x57f8d
xorl %eax, %ecx
xorl $0x1, %eax
orl %ecx, %eax
jne 0x57f8b
movl 0x4(%r14), %eax
cmpl 0x4(%rbx), %eax
sete %al
jmp 0x57f8d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/ir_liveness_analysis.cpp
// Function: isFound(std::unordered_set<ir::Opn*, std::hash<ir::Opn*>, std::equal_to<ir::Opn*>, std::allocator<ir::Opn*>>&, ir::Opn*)
bool isFound(std::unordered_set<Opn *> &inbb, Opn *inir) {
  for (auto i : inbb) {
    if (i->name_ == inir->name_ && i->scope_id_ == inir->scope_id_) {
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x59768
movq %rsi, %rbx
movq 0x10(%rsi), %r14
movq 0x8(%r15), %r12
cmpq %r14, 0x10(%r12)
jne 0x59760
testq %r14, %r14
je 0x59756
movq 0x8(%rbx), %rsi
movq 0x8(%r12), %rdi
movq %r14, %rdx
callq 0x82b0
testl %eax, %eax
jne 0x59760
movl 0x28(%r12), %eax
cmpl 0x28(%rbx), %eax
je 0x59776
movq (%r15), %r15
testq %r15, %r15
jne 0x59731
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x5976a
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/ir_liveness_analysis.cpp
// Function: IRLivenessAnalysis::Run()
void IRLivenessAnalysis::Run() {
  auto m = dynamic_cast<IRModule *>(*(this->m_));

  MyAssert(nullptr != m);

  for (auto func : m->func_list_) {
    // std::cout << "analysis func:" << func->name_ << std::endl;
    this->Run4Func(func);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x59c27
leaq 0x33a57(%rip), %rsi     # 0x8d648
leaq 0x34478(%rip), %rdx     # 0x8e070
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
je 0x59c27
movq 0x28(%rax), %rbx
movq 0x30(%rax), %r14
cmpq %r14, %rbx
je 0x59c1f
movq (%rbx), %rdi
callq 0x598b4
addq $0x8, %rbx
jmp 0x59c0c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x353ba(%rip), %rdi     # 0x8efe8
leaq 0x14533(%rip), %rsi     # 0x6e168
callq 0x8280
leaq 0x17e08(%rip), %rsi     # 0x71a49
movq %rax, %rdi
callq 0x8280
leaq 0x15770(%rip), %rsi     # 0x6f3c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0xf9, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
nop
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/loop_invariant_extrapolation.cpp
// Function: cross(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
vector<int> cross(vector<int> a, vector<int> b) {
  vector<int> ret;
  int ia = 0, ib = 0;
  while (ia < a.size() and ib < b.size()) {
    if (a[ia] < b[ib])
      ia++;
    else if (a[ia] > b[ib])
      ib++;
    else {
      ret.push_back(a[ia]);
      ia++, ib++;
    }
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
cmpq %rax, %rcx
je 0x5a75f
movq %rdx, %r14
movq %rsi, %r15
xorl %edx, %edx
xorl %ebp, %ebp
xorl %r12d, %r12d
movslq %r12d, %rsi
movq (%r14), %r8
movq 0x8(%r14), %rdi
subq %r8, %rdi
sarq $0x2, %rdi
cmpq %rsi, %rdi
jbe 0x5a75f
movl (%rax,%rdx,4), %edi
cmpl (%r8,%rsi,4), %edi
jge 0x5a71d
incl %ebp
jmp 0x5a74d
jg 0x5a74a
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5a735
movl %edi, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5a748
leaq (%rax,%rdx,4), %rdx
movq %rbx, %rdi
callq 0x129f6
movq (%r15), %rax
movq 0x8(%r15), %rcx
incl %ebp
incl %r12d
movslq %ebp, %rdx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x2, %rsi
cmpq %rdx, %rsi
ja 0x5a6fa
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5a782
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x82a0
movq %r14, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/loop_invariant_extrapolation.cpp
// Function: will_not_live(std::pair<int, int>, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>, std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
bool will_not_live(pair<int, int> pos, vector<pair<int, int> > use, vector<int> suc,
                   vector<int> loop)  // use为变量x的use，suc为loop的后续节点
{
  set<int> se;
  for (int i = 0; i < use.size(); i++) se.insert(use[i].first);
  for (int i = 0; i < suc.size(); i++) {
    if (se.find(suc[i]) != se.end()) return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x10(%rsp), %r12
movl $0x0, (%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
movq %rax, 0x20(%r12)
movq (%rsi), %rsi
cmpq %rsi, 0x8(%r14)
je 0x5aa94
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
addq %r13, %rsi
movq %r15, %rdi
callq 0x3a804
incq %rbp
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
addq $0x8, %r13
cmpq %rbp, %rax
ja 0x5aa6f
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
je 0x5ab0e
sarq $0x2, %rcx
movq 0x18(%rsp), %rdx
cmpq $0x1, %rcx
movq %rcx, %rsi
adcq $0x0, %rsi
xorl %edi, %edi
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x5aafe
movl (%rax,%rdi,4), %r8d
movq %rdx, %r15
movq %r12, %r14
movq %r14, %r9
movq %r15, %r10
movl 0x20(%r15), %r11d
xorl %r15d, %r15d
cmpl %r8d, %r11d
setl %r15b
movq %r10, %r14
cmovlq %r9, %r14
movq 0x10(%r10,%r15,8), %r15
testq %r15, %r15
jne 0x5aac7
cmpq %r12, %r14
je 0x5aafe
cmpl %r8d, %r11d
cmovlq %r9, %r10
cmpl 0x20(%r10), %r8d
jge 0x5ab10
incq %rdi
cmpq %rdi, %rcx
setbe %bl
cmpq %rsi, %rdi
jne 0x5aab8
jmp 0x5ab10
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x3b008
andb $0x1, %bl
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3b008
movq %rbx, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/loop_invariant_extrapolation.cpp
// Function: check2(std::pair<int, int>, std::vector<int, std::allocator<int>>, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>)
bool check2(pair<int, int> pos, vector<int> loop,
            vector<pair<int, int> > def)  // pos为当前的基本块，要看loop中除了pos以外其他的基本块在不在def中
{
  set<int> se;
  for (int i = 0; i < def.size(); i++) {
    if (def[i] == pos) continue;
    se.insert(def[i].first);
  }
  for (int i = 0; i < loop.size(); i++) {
    if (se.find(loop[i]) != se.end()) return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, (%rsp)
leaq 0x10(%rsp), %r13
movl $0x0, (%r13)
xorl %eax, %eax
movq %rax, 0x8(%r13)
movq %r13, 0x10(%r13)
movq %r13, 0x18(%r13)
movq %rax, 0x20(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rax
cmpq %rsi, %rax
je 0x5abc8
movq %rdx, %r14
movq %rdi, %r15
movq %rdi, %rbp
shrq $0x20, %rbp
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpl %r15d, (%rsi,%rbx)
jne 0x5ab9e
cmpl %ebp, 0x4(%rsi,%rbx)
je 0x5abb2
addq %rbx, %rsi
leaq 0x8(%rsp), %rdi
callq 0x3a804
movq (%r14), %rsi
movq 0x8(%r14), %rax
incq %r12
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x3, %rcx
addq $0x8, %rbx
cmpq %r12, %rcx
ja 0x5ab92
movq (%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
je 0x5ac46
sarq $0x2, %rcx
movq 0x18(%rsp), %rdx
cmpq $0x1, %rcx
movq %rcx, %rsi
adcq $0x0, %rsi
xorl %edi, %edi
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x5ac36
movl (%rax,%rdi,4), %r8d
movq %rdx, %r15
movq %r13, %r14
movq %r14, %r9
movq %r15, %r10
movl 0x20(%r15), %r11d
xorl %r15d, %r15d
cmpl %r8d, %r11d
setl %r15b
movq %r10, %r14
cmovlq %r9, %r14
movq 0x10(%r10,%r15,8), %r15
testq %r15, %r15
jne 0x5abff
cmpq %r13, %r14
je 0x5ac36
cmpl %r8d, %r11d
cmovlq %r9, %r10
cmpl 0x20(%r10), %r8d
jge 0x5ac48
incq %rdi
cmpq %rdi, %rcx
setbe %bl
cmpq %rsi, %rdi
jne 0x5abf0
jmp 0x5ac48
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x3b008
andb $0x1, %bl
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3b008
movq %rbx, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/loop_unroll.cpp
// Function: cross(std::vector<IRBasicBlock*, std::allocator<IRBasicBlock*>>, std::vector<IRBasicBlock*, std::allocator<IRBasicBlock*>>)
vector<IRBasicBlock*> cross(vector<IRBasicBlock*> a, vector<IRBasicBlock*> b) {
  sort(a.begin(), a.end()), sort(b.begin(), b.end());
  vector<IRBasicBlock*> res;
  int ia = 0, ib = 0;
  while (ia < a.size() && ib < b.size()) {
    if (a[ia] < b[ib])
      ia++;
    else if (a[ia] > b[ib])
      ib++;
    else {
      res.push_back(a[ia]);
      ia++, ib++;
    }
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x62e99
movq %r13, %rax
subq %r12, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x67f5f
movq %r12, %rdi
movq %r13, %rsi
callq 0x68048
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x62ed2
movq %r13, %rax
subq %r12, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x67f5f
movq %r12, %rdi
movq %r13, %rsi
callq 0x68048
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r15), %rax
movq 0x8(%r15), %rcx
cmpq %rax, %rcx
je 0x62f5c
xorl %edx, %edx
xorl %ebp, %ebp
xorl %r12d, %r12d
movslq %r12d, %rsi
movq (%r14), %r8
movq 0x8(%r14), %rdi
subq %r8, %rdi
sarq $0x3, %rdi
cmpq %rsi, %rdi
jbe 0x62f5c
movq (%rax,%rdx,8), %rdi
cmpq (%r8,%rsi,8), %rdi
jae 0x62f17
incl %ebp
jmp 0x62f4a
jbe 0x62f1e
incl %r12d
jmp 0x62f4a
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x62f32
movq %rdi, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x62f3e
leaq (%rax,%rdx,8), %rdx
movq %rbx, %rdi
callq 0x117de
incl %ebp
incl %r12d
movq (%r15), %rax
movq 0x8(%r15), %rcx
movslq %ebp, %rdx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
cmpq %rdx, %rsi
ja 0x62ef3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x62f85
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x82a0
movq %r14, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/reach_define.cpp
// Function: print_map(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::unordered_set<ir::IR*, std::hash<ir::IR*>, std::equal_to<ir::IR*>, std::allocator<ir::IR*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unordered_set<ir::IR*, std::hash<ir::IR*>, std::equal_to<ir::IR*>, std::allocator<ir::IR*>>>>>)
void print_map(std::unordered_map<std::string, std::unordered_set<ir::IR *>> umap) {
  for (auto iter : umap) {
    std::cout << iter.first << ": " << iter.second.size() << std::endl;
    for (auto ir : iter.second) {
      ir->PrintIR();
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x68b17
movq %rsp, %r14
movq 0x26563(%rip), %r15     # 0x8efb8
leaq 0x6894(%rip), %r12      # 0x6f2f0
movq 0x26515(%rip), %r13     # 0x8ef78
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x6a94c
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x8330
movq %rax, %rbp
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x8330
movq 0x38(%rsp), %rsi
movq %rbp, %rdi
callq 0x81e0
movq %rax, %rbp
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %rbp, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x30(%rsp), %rbp
testq %rbp, %rbp
je 0x68ae6
movq 0x8(%rbp), %rdi
movq %r13, %rsi
callq 0x29b96
movq (%rbp), %rbp
jmp 0x68acf
leaq 0x20(%rsp), %rdi
callq 0x2c012
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x68b0b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x82a0
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x68a63
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x68b28
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6a9d6
movq %rbx, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/reach_define.cpp
// Function: isSameOpn(ir::Opn, ir::Opn)
bool isSameOpn(ir::Opn opn1, ir::Opn opn2) {
  if (opn1.type_ == opn2.type_) {
    if (ir::Opn::Type::Var == opn1.type_) {
      // std::cout << "opn1:" << opn1.name_ + "_#" + std::to_string(opn1.scope_id_) + "\n";
      // std::cout << "opn2:" << opn2.name_ + "_#" + std::to_string(opn2.scope_id_) + "\n";
      return opn1.name_ == opn2.name_ && opn1.scope_id_ == opn2.scope_id_;
    }
    return false;
  }

  return false;
}

// Assembly:
movl (%rsi), %eax
orl (%rdi), %eax
je 0x69bd5
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdx
cmpq 0x10(%rsi), %rdx
jne 0x69bff
testq %rdx, %rdx
je 0x69c03
movq 0x8(%rbx), %rsi
movq 0x8(%r14), %rdi
callq 0x82b0
testl %eax, %eax
je 0x69c03
xorl %eax, %eax
jmp 0x69c0d
movl 0x28(%r14), %eax
cmpl 0x28(%rbx), %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/luooofan[P]hblzbd_compiler/src/Pass/reach_define.cpp
// Function: finddef(IRBasicBlock*, ir::IR*, ir::Opn*)
ir::IR *finddef(IRBasicBlock *bb, ir::IR *ir, ir::Opn *opn) {
  auto it = find(bb->ir_list_.begin(), bb->ir_list_.end(), ir);

  for (auto iter = it - 1; iter != bb->ir_list_.begin() - 1; --iter) {
    auto def = *iter;

    if (isSameOpn(def->res_, *opn)) {
      // printf("/*************************\n");
      return def;
    }
  }

  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, %r14
leaq 0x10(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rsi
callq 0x4a58e
movq %rax, %r15
leaq 0x18(%rsp), %r12
leaq 0x58(%rsp), %r13
cmpq 0x8(%r14), %r15
je 0x69cc4
addq $-0x8, %r15
movq (%r15), %rbp
leaq 0x88(%rbp), %rsi
movq %r12, %rdi
callq 0x28816
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x28816
movq %r12, %rdi
movq %r13, %rsi
callq 0x69bcc
movl %eax, %ebx
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x69ca2
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x82a0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x69cbe
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x82a0
testb %bl, %bl
je 0x69c50
jmp 0x69cc6
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x69cfa
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x82a0
movq %rbx, %rdi
callq 0x8540