LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x109a0
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x109d0
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x10a00
testb $0x1, %al
jne 0x87efa
jmp 0x88015
leaq 0x60(%rsp), %rdi
callq 0x10a20
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x3e850
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x8d1d0
movq %rax, 0x40(%rsp)
movl $0x68, %edi
callq 0x8340
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
testb $0x1, (%rax)
je 0x87f64
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a60
movl (%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x87f6f
movl $0x4, %eax
movl %eax, 0xc(%rsp)
jmp 0x87f6f
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
callq 0x8d1e0
jmp 0x87f84
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
testb $0x1, 0x1(%rax)
je 0x87fd1
movq 0x40(%rsp), %rsi
addq $0x38, %rsi
movq 0x38(%rsp), %rdi
addq $0x48, %rdi
callq 0x361c0
jmp 0x87fd1
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x68, %esi
callq 0x8350
jmp 0x8801d
movq 0x70(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x60e30
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
addq $0xe0, %rdi
movq 0x48(%rsp), %rsi
callq 0x8cd60
movq (%rsp), %rcx
movq %rcx, (%rax)
leaq 0x60(%rsp), %rdi
callq 0x10ad0
jmp 0x87ee2
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x8670
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x9f277
movq 0x10(%rsp), %rdi
leaq 0xab377(%rip), %rsi     # 0x14a5d8
leaq 0xac6e8(%rip), %rdx     # 0x14b950
xorl %eax, %eax
movl %eax, %ecx
callq 0x8410
movq %rax, (%rsp)
jmp 0x9f27f
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x9f27f
movq (%rsp), %rax
movq %rax, 0x38(%rsp)
xorl %eax, %eax
cmpq 0x38(%rsp), %rax
jne 0x9f2e8
movq 0xacd50(%rip), %rdi     # 0x14bfe8
leaq 0x5ae59(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0x5e628(%rip), %rsi     # 0xfd8d6
callq 0x8330
movq %rax, %rdi
leaq 0x5c12d(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x10, %esi
callq 0x8650
movq %rax, %rdi
movq 0xacca7(%rip), %rsi     # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x9f3b0
movq 0x8(%rsp), %rsi
movq 0x38(%rsp), %rdi
addq $0x38, %rsi
callq 0x9f6e0
movq 0x38(%rsp), %rdi
callq 0xa0ee0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x624d0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x62500
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x62530
testb $0x1, %al
jne 0x9f34c
jmp 0x9f392
leaq 0x28(%rsp), %rdi
callq 0x62550
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x9fcd0
movq 0x18(%rsp), %rdi
callq 0x61100
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xa00f0
leaq 0x28(%rsp), %rdi
callq 0x62570
jmp 0x9f337
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x9f3b0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xa0f50
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x62a60
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xa10f0
testb $0x1, %al
jne 0xa0d86
jmp 0xa0d8b
jmp 0xa0ed9
movq 0x58(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xa0f10
movq 0x60(%rsp), %rdi
callq 0x62a20
movq %rax, %rdi
callq 0x5e2d0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5e160
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5e1b0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5e190
testb $0x1, %al
jne 0xa0de7
jmp 0xa0ed9
leaq 0x38(%rsp), %rdi
callq 0x5e1e0
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x60410
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xa0e31
movq 0x10(%rsp), %rdi
leaq 0xaa7f6(%rip), %rsi     # 0x14b610
leaq 0xaa8ef(%rip), %rdx     # 0x14b710
xorl %eax, %eax
movl %eax, %ecx
callq 0x8410
movq %rax, 0x8(%rsp)
jmp 0xa0e3a
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xa0e3a
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
cmpq 0x20(%rsp), %rax
jne 0xa0ea4
movq 0xab194(%rip), %rdi     # 0x14bfe8
leaq 0x5929d(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0x5ca6c(%rip), %rsi     # 0xfd8d6
callq 0x8330
movq %rax, %rdi
leaq 0x5a571(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x75, %esi
callq 0x8650
movq %rax, %rdi
movq 0xab0eb(%rip), %rsi     # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movq 0x20(%rsp), %rdi
callq 0x5e2b0
movq %rax, %rdi
callq 0x5e2c0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xa0d40
leaq 0x38(%rsp), %rdi
callq 0x5e280
jmp 0xa0dcf
addq $0x68, %rsp
retq
nop
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x50, %rdi
leaq 0x90(%rsp), %rsi
callq 0xa5e50
movq 0x18(%rsp), %rdi
movq %rax, 0x88(%rsp)
addq $0x50, %rdi
callq 0xa5e80
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xa5e30
testb $0x1, %al
jne 0xa4f76
jmp 0xa4f7b
jmp 0xa50b4
movq 0x18(%rsp), %rdx
movq %rdx, %rax
addq $0x50, %rax
movq %rax, (%rsp)
addq $0x34, %rdx
leaq 0x70(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xa5f00
movq (%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xa5eb0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x60(%rsp)
movb %dl, 0x68(%rsp)
movq 0x90(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq %rax, %rdi
addq $0x38, %rdi
movslq 0x34(%rax), %rsi
callq 0x8ee50
movq 0x8(%rsp), %rdx
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rdx, (%rcx)
addq $0x88, %rax
movq %rax, 0x10(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0xa5f80
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xa5f30
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x40(%rsp)
movb %dl, 0x48(%rsp)
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
movq 0x90(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1cc40
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1cac0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x492e0
testb $0x1, %al
jne 0xa507f
jmp 0xa50b4
leaq 0x30(%rsp), %rdi
callq 0x49320
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x90(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xa4f00
leaq 0x30(%rsp), %rdi
callq 0x49330
jmp 0xa506a
addq $0xa8, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x38, %rdi
callq 0xa6090
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
callq 0xa60b0
movq 0x10(%rsp), %rdi
addq $0x88, %rdi
callq 0xa60c0
movq 0x10(%rsp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0xa60c0
movq 0x10(%rsp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
callq 0xa60d0
movq 0x10(%rsp), %rdi
addq $0xc0, %rdi
callq 0xa60c0
movq 0x10(%rsp), %rdi
addq $0x168, %rdi            # imm = 0x168
callq 0xa60c0
movq 0x10(%rsp), %rdi
addq $0xf8, %rdi
callq 0xa60c0
movq 0x10(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
callq 0x1cd80
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xa60e0
movq 0x10(%rsp), %rax
movl $0x0, 0x34(%rax)
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
movq 0x88(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x1cc40
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x1cac0
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x492e0
testb $0x1, %al
jne 0xa5b40
jmp 0xa5b98
leaq 0x78(%rsp), %rdi
callq 0x49320
movq (%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x250(%rax), %rax
cmpq 0x88(%rsp), %rax
je 0xa5b8a
movq 0x88(%rsp), %rdi
addq $0x270, %rdi            # imm = 0x270
leaq 0x68(%rsp), %rsi
callq 0x8f780
movq %rax, 0x58(%rsp)
movb %dl, 0x60(%rsp)
jmp 0xa5b8c
leaq 0x78(%rsp), %rdi
callq 0x49330
jmp 0xa5b2b
movq 0x88(%rsp), %rax
addq $0x258, %rax            # imm = 0x258
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1cc40
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1cac0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x492e0
testb $0x1, %al
jne 0xa5be1
jmp 0xa5cbe
leaq 0x48(%rsp), %rdi
callq 0x49320
movq (%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
callq 0xa5ad0
movq 0x38(%rsp), %rax
addq $0x270, %rax            # imm = 0x270
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8d590
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8d5c0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x8d5f0
testb $0x1, %al
jne 0xa5c44
jmp 0xa5cad
leaq 0x28(%rsp), %rdi
callq 0x8d610
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x491b0
testb $0x1, %al
jne 0xa5c6e
jmp 0xa5c7d
movq 0x18(%rsp), %rax
cmpq 0x88(%rsp), %rax
jne 0xa5c9f
movq 0x88(%rsp), %rdi
addq $0x270, %rdi            # imm = 0x270
leaq 0x18(%rsp), %rsi
callq 0x8f780
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
jmp 0xa5ca1
leaq 0x28(%rsp), %rdi
callq 0x8d670
jmp 0xa5c2f
jmp 0xa5caf
leaq 0x48(%rsp), %rdi
callq 0x49330
jmp 0xa5bc9
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xa5d17
movq 0x10(%rsp), %rdi
leaq 0xa48d7(%rip), %rsi     # 0x14a5d8
leaq 0xa5330(%rip), %rdx     # 0x14b038
xorl %eax, %eax
movl %eax, %ecx
callq 0x8410
movq %rax, (%rsp)
jmp 0xa5d1f
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0xa5d1f
movq (%rsp), %rax
movq %rax, 0x38(%rsp)
xorl %eax, %eax
cmpq 0x38(%rsp), %rax
jne 0xa5d88
movq 0xa62b0(%rip), %rdi     # 0x14bfe8
leaq 0x543b9(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0x57bf6(%rip), %rsi     # 0xfd944
callq 0x8330
movq %rax, %rdi
leaq 0x5568d(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x83, %esi
callq 0x8650
movq %rax, %rdi
movq 0xa6207(%rip), %rsi     # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movq 0x38(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1d3c0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1d240
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x49210
testb $0x1, %al
jne 0xa5dc9
jmp 0xa5e20
leaq 0x28(%rsp), %rdi
callq 0x49250
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0xa5400
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xa54d0
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
callq 0x8cc90
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0xa5ad0
leaq 0x28(%rsp), %rdi
callq 0x49260
jmp 0xa5db4
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: luooofan[P]hblzbd_compiler/src/Pass/generate_arm_from_ssa.cpp
// Function: GenerateArmFromSSA::GetCondType(BranchInst::Cond, bool)
Cond GenerateArmFromSSA::GetCondType(BranchInst::Cond cond, bool exchange) {
  if (exchange) {
    switch (cond) {
      case BranchInst::Cond::EQ:
        return Cond::EQ;
      case BranchInst::Cond::NE:
        return Cond::NE;
      case BranchInst::Cond::GT:
        return Cond::LT;
      case BranchInst::Cond::GE:
        return Cond::LE;
      case BranchInst::Cond::LT:
        return Cond::GT;
      case BranchInst::Cond::LE:
        return Cond::GE;
      default:
        return Cond::AL;
    }
  } else {
    switch (cond) {
      case BranchInst::Cond::EQ:
        return Cond::EQ;
      case BranchInst::Cond::NE:
        return Cond::NE;
      case BranchInst::Cond::GT:
        return Cond::GT;
      case BranchInst::Cond::GE:
        return Cond::GE;
      case BranchInst::Cond::LT:
        return Cond::LT;
      case BranchInst::Cond::LE:
        return Cond::LE;
      default:
        return Cond::AL;
    }
  }
}

// Assembly:
movb %dl, %al
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
andb $0x1, %al
movb %al, -0x15(%rsp)
testb $0x1, -0x15(%rsp)
je 0xaaf01
movl -0x14(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rsp)
subl $0x5, %eax
ja 0xaaef7
movq -0x20(%rsp), %rax
leaq 0x52ae2(%rip), %rcx     # 0xfd988
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rsp)
jmp 0xaaf6c
movl $0x2, -0x4(%rsp)
jmp 0xaaf6c
movl $0x5, -0x4(%rsp)
jmp 0xaaf6c
movl $0x6, -0x4(%rsp)
jmp 0xaaf6c
movl $0x3, -0x4(%rsp)
jmp 0xaaf6c
movl $0x4, -0x4(%rsp)
jmp 0xaaf6c
movl $0x0, -0x4(%rsp)
jmp 0xaaf6c
movl -0x14(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rsp)
subl $0x5, %eax
ja 0xaaf64
movq -0x28(%rsp), %rax
leaq 0x52a51(%rip), %rcx     # 0xfd970
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rsp)
jmp 0xaaf6c
movl $0x2, -0x4(%rsp)
jmp 0xaaf6c
movl $0x3, -0x4(%rsp)
jmp 0xaaf6c
movl $0x4, -0x4(%rsp)
jmp 0xaaf6c
movl $0x5, -0x4(%rsp)
jmp 0xaaf6c
movl $0x6, -0x4(%rsp)
jmp 0xaaf6c
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0xacfc0
movq 0x28(%rsp), %rdi
leaq 0x9e527(%rip), %rsi     # 0x14b4d0
leaq 0x9e548(%rip), %rdx     # 0x14b4f8
xorl %eax, %eax
movl %eax, %ecx
callq 0x8410
movq %rax, 0x18(%rsp)
jmp 0xacfc9
xorl %eax, %eax
movq %rax, 0x18(%rsp)
jmp 0xacfc9
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xad009
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5e800
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %eax, %edx
xorl %ecx, %ecx
callq 0xab2c0
movq %rax, 0x60(%rsp)
jmp 0xad06b
movl $0x18, %edi
callq 0x8340
movq 0x20(%rsp), %rdi
movq %rax, (%rsp)
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0xabf80
movq %rax, 0x8(%rsp)
jmp 0xad032
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0x78090
jmp 0xad042
movq (%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0xad06b
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x18, %esi
callq 0x8350
jmp 0xad075
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x8670
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movq 0x110(%rdi), %rsi
xorl %edx, %edx
movl %edx, 0x34(%rsp)
movl $0x1, %ecx
callq 0xab2c0
movq %rax, 0x60(%rsp)
movl $0x38, %edi
callq 0x8340
movq 0x40(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq %rax, 0x10(%rsp)
addq $0x38, %rdi
movq %rdi, 0x18(%rsp)
movl $0xd, %esi
movq %rsi, 0x20(%rsp)
callq 0xcd90
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rax), %rax
movq %rax, 0x38(%rsp)
callq 0xcd90
movq 0x28(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x38(%rsp), %rdx
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq (%rcx), %rcx
movq 0x60(%rsp), %r8
movq 0x110(%rax), %r9
callq 0xb23b0
jmp 0xad578
movq 0x60(%rsp), %rax
testb $0x1, (%rax)
je 0xad5fb
movq 0x9ea5f(%rip), %rdi     # 0x14bfe8
leaq 0x4cb68(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0x5042a(%rip), %rsi     # 0xfd9c9
callq 0x8330
movq %rax, %rdi
leaq 0x4de3c(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x16f, %esi            # imm = 0x16F
callq 0x8650
movq %rax, %rdi
movq 0x9e9b6(%rip), %rsi     # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x38, %esi
callq 0x8350
jmp 0xad69a
movl $0x30, %edi
callq 0x8340
movq %rax, %rdi
movq 0x40(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movq 0x110(%rax), %rdx
movl $0x1, %esi
callq 0xb2510
jmp 0xad628
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
addq $0x18, %rax
movq %rax, (%rsp)
addq $0x38, %rdi
movl $0xf, %esi
callq 0xcd90
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x7d1c0
movq 0x40(%rsp), %rsi
movq 0x68(%rsp), %rdi
addq $0x38, %rdi
addq $0x110, %rsi            # imm = 0x110
callq 0xb2640
addq $0x78, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x30, %esi
callq 0x8350
movq 0x58(%rsp), %rdi
callq 0x8670
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x38, %rdi
callq 0x80ae0
movl $0x0, 0x3c(%rsp)
cmpl $0x10, 0x3c(%rsp)
jge 0xad74e
movq 0x18(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x8(%rsp)
movl $0x40, %edi
callq 0x8340
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl 0x3c(%rsp), %esi
callq 0x77bb0
jmp 0xad709
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x7d230
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0xad6d4
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x40, %esi
callq 0x8350
jmp 0xad7af
movq 0x18(%rsp), %rdi
movl $0x10, 0x50(%rdi)
addq $0x58, %rdi
callq 0xb26b0
movq 0x18(%rsp), %rdi
movl $0x0, 0x90(%rdi)
addq $0x98, %rdi
callq 0x80d90
movq 0x18(%rsp), %rdi
addq $0xd0, %rdi
callq 0x80d90
movq 0x18(%rsp), %rax
movq $0x0, 0x108(%rax)
movq $0x0, 0x110(%rax)
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x8670
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xb1e48
movq 0x18(%rsp), %rdi
leaq 0x987a7(%rip), %rsi     # 0x14a5d8
leaq 0x99b18(%rip), %rdx     # 0x14b950
xorl %eax, %eax
movl %eax, %ecx
callq 0x8410
movq %rax, 0x8(%rsp)
jmp 0xb1e51
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xb1e51
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
xorl %eax, %eax
cmpq 0x28(%rsp), %rax
jne 0xb1ebb
movq 0x9a17d(%rip), %rdi     # 0x14bfe8
leaq 0x48286(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0x4bb48(%rip), %rsi     # 0xfd9c9
callq 0x8330
movq %rax, %rdi
leaq 0x4955a(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x336, %esi            # imm = 0x336
callq 0x8650
movq %rax, %rdi
movq 0x9a0d4(%rip), %rsi     # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xadf90
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xb1efc
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movb %cl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
xorl %eax, %eax
cmpq 0x50(%rsp), %rax
jne 0xbc37b
movq 0x8fcbd(%rip), %rdi     # 0x14bfe8
leaq 0x3ddc6(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0x4172e(%rip), %rsi     # 0xfda6f
callq 0x8330
movq %rax, %rdi
leaq 0x3f09a(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x17f, %esi            # imm = 0x17F
callq 0x8650
movq %rax, %rdi
movq 0x8fc14(%rip), %rsi     # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xbdf00
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
callq 0xbd8b0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xbdee0
testb $0x1, %al
jne 0xbc3b6
jmp 0xbc4db
movq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x62fb0
movq %rax, 0x28(%rsp)
movb %dl, 0x30(%rsp)
testb $0x1, 0x4f(%rsp)
je 0xbc3e5
movq 0x50(%rsp), %rdi
callq 0x62810
movq %rax, (%rsp)
jmp 0xbc3f3
movq 0x50(%rsp), %rdi
callq 0x62710
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x62720
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x62750
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x62780
testb $0x1, %al
jne 0xbc432
jmp 0xbc4cc
leaq 0x18(%rsp), %rdi
callq 0x627a0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpq 0x8(%rsp), %rax
jne 0xbc4a4
movq 0x8fb94(%rip), %rdi     # 0x14bfe8
leaq 0x3dc9d(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0x41605(%rip), %rsi     # 0xfda6f
callq 0x8330
movq %rax, %rdi
leaq 0x3ef71(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x183, %esi            # imm = 0x183
callq 0x8650
movq %rax, %rdi
movq 0x8faeb(%rip), %rsi     # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl $0x1, %ecx
callq 0xbc300
leaq 0x18(%rsp), %rdi
callq 0x627f0
jmp 0xbc41a
movq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x90590
addq $0x68, %rsp
retq
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movb $0x0, 0x87(%rsp)
callq 0x904b0
leaq 0x48(%rsp), %rdi
callq 0x50420
movq 0x88(%rsp), %rdi
callq 0x62c10
movq %rax, 0x20(%rsp)
jmp 0xbc52f
movq 0x20(%rsp), %rdi
callq 0xb27d0
cmpq $0x0, %rax
jbe 0xbc59c
movq 0x88(%rsp), %rdi
callq 0x62c10
movq %rax, 0x8(%rsp)
jmp 0xbc553
movq 0x8(%rsp), %rdi
callq 0xbd950
movq 0x10(%rsp), %rdi
movq (%rax), %rdx
leaq 0x48(%rsp), %rsi
movl $0x1, %ecx
callq 0xbc300
jmp 0xbc576
jmp 0xbc59c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x63010
movq 0x10(%rsp), %rdi
callq 0x63020
jmp 0xbc5fe
movq 0x10(%rsp), %rdi
callq 0x90970
movq 0x10(%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0x907f0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xbdf30
jmp 0xbc5cb
movb $0x1, 0x87(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x63010
testb $0x1, 0x87(%rsp)
jne 0xbc5f1
movq 0x10(%rsp), %rdi
callq 0x63020
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x8670
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0xc7bb1
movq (%rsp), %rax
cmpl $0x0, (%rax)
jne 0xc7bb1
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x1a650
testb $0x1, %al
jne 0xc7b92
jmp 0xc7baa
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movl 0x28(%rax), %eax
cmpl 0x28(%rcx), %eax
jne 0xc7baa
movb $0x1, 0x27(%rsp)
jmp 0xc7c06
movb $0x0, 0x27(%rsp)
jmp 0xc7c06
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movl (%rax), %eax
cmpl (%rcx), %eax
jne 0xc7bcb
movq (%rsp), %rax
cmpl $0x5, (%rax)
jne 0xc7bcb
jmp 0xc7bff
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movl (%rax), %eax
cmpl (%rcx), %eax
jne 0xc7bfd
movq (%rsp), %rax
cmpl $0x1, (%rax)
jne 0xc7bfd
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movl 0x4(%rax), %eax
cmpl 0x4(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xc7c06
jmp 0xc7bff
jmp 0xc7c01
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc9fb0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc9fe0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xca010
testb $0x1, %al
jne 0xc923b
jmp 0xc928e
leaq 0x10(%rsp), %rdi
callq 0xca030
movq (%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rsi
addq $0x8, %rsi
callq 0x1a650
testb $0x1, %al
jne 0xc9268
jmp 0xc9280
movq (%rsp), %rax
movl 0x28(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jne 0xc9280
movb $0x1, 0x37(%rsp)
jmp 0xc9293
jmp 0xc9282
leaq 0x10(%rsp), %rdi
callq 0xca050
jmp 0xc9226
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xc9dc3
movq 0x10(%rsp), %rdi
leaq 0x8082c(%rip), %rsi     # 0x14a5d8
leaq 0x81285(%rip), %rdx     # 0x14b038
xorl %eax, %eax
movl %eax, %ecx
callq 0x8410
movq %rax, 0x8(%rsp)
jmp 0xc9dcc
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xc9dcc
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
xorl %eax, %eax
cmpq 0x38(%rsp), %rax
jne 0xc9e36
movq 0x82202(%rip), %rdi     # 0x14bfe8
leaq 0x3030b(%rip), %rsi     # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0x33caf(%rip), %rsi     # 0xfdaab
callq 0x8330
movq %rax, %rdi
leaq 0x315df(%rip), %rsi     # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0xf9, %esi
callq 0x8650
movq %rax, %rdi
movq 0x82159(%rip), %rsi     # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
movq 0x38(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1d3c0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1d240
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x49210
testb $0x1, %al
jne 0xc9e77
jmp 0xc9e9f
leaq 0x28(%rsp), %rdi
callq 0x49250
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc95c0
leaq 0x28(%rsp), %rdi
callq 0x49260
jmp 0xc9e62
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x78, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movb $0x0, 0x5f(%rsp)
callq 0x35d90
movl $0x0, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x10a40
movq 0x10(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x1f(%rsp)
jae 0xcc661
movq 0x20(%rsp), %rdi
movslq 0x54(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x10a40
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xcc66e
jmp 0xcc73e
movq 0x28(%rsp), %rdi
movslq 0x58(%rsp), %rsi
callq 0x10a60
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movslq 0x54(%rsp), %rsi
callq 0x10a60
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
jge 0xcc6ad
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0xcc739
movq 0x28(%rsp), %rdi
movslq 0x58(%rsp), %rsi
callq 0x10a60
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, (%rsp)
movslq 0x54(%rsp), %rsi
callq 0x10a60
movq %rax, %rcx
movl (%rsp), %eax
cmpl (%rcx), %eax
jle 0xcc6e7
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xcc737
movq 0x28(%rsp), %rdi
movslq 0x58(%rsp), %rsi
callq 0x10a60
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x1f2a0
jmp 0xcc705
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xcc737
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x35c60
jmp 0xcc75e
jmp 0xcc739
jmp 0xcc614
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0xcc754
movq 0x30(%rsp), %rdi
callq 0x35c60
movq 0x38(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x8670
nopl (%rax,%rax)
// File: 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:
subq $0xd8, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0xcc(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movq %rcx, 0xb0(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x6eec0
movl $0x0, 0x7c(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x7c(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0xd4b70
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0xcccb0
movq 0x28(%rsp), %rdi
movslq 0x7c(%rsp), %rsi
callq 0xd4bf0
movq %rax, %rsi
leaq 0x80(%rsp), %rdi
callq 0x75710
movb %dl, 0x17(%rsp)
movq %rax, 0x18(%rsp)
jmp 0xccc71
movb 0x17(%rsp), %al
movq 0x18(%rsp), %rcx
movq %rcx, 0x58(%rsp)
movb %al, 0x60(%rsp)
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0xccc26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x6f180
jmp 0xccd80
movl $0x0, 0x54(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x54(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x10a40
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xccd52
movq 0x30(%rsp), %rdi
movslq 0x54(%rsp), %rsi
callq 0x10a60
movq %rax, %rsi
leaq 0x80(%rsp), %rdi
callq 0x80a70
movq %rax, (%rsp)
jmp 0xcccfe
movq (%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x80ab0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x80a50
testb $0x1, %al
jne 0xccd2e
jmp 0xccd40
movb $0x0, 0xd7(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0xccd62
jmp 0xccd42
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xcccb8
movb $0x1, 0xd7(%rsp)
movl $0x1, 0x3c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x6f180
movb 0xd7(%rsp), %al
andb $0x1, %al
addq $0xd8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x8670
nopw (%rax,%rax)
// File: 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:
subq $0xd8, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0xcc(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x6eec0
movl $0x0, 0x84(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x84(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0xd4b70
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0xccea2
movq 0x38(%rsp), %rdi
movslq 0x84(%rsp), %rsi
callq 0xd4bf0
movq %rax, %rdi
leaq 0xcc(%rsp), %rsi
callq 0xd4d30
movb %al, 0x27(%rsp)
jmp 0xcce21
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xcce2b
jmp 0xcce4d
jmp 0xcce8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x6f180
jmp 0xccf72
movq 0x38(%rsp), %rdi
movslq 0x84(%rsp), %rsi
callq 0xd4bf0
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x75710
movb %dl, 0x17(%rsp)
movq %rax, 0x18(%rsp)
jmp 0xcce7a
movb 0x17(%rsp), %al
movq 0x18(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movb %al, 0x68(%rsp)
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0xccdd1
movl $0x0, 0x5c(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x5c(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x10a40
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xccf44
movq 0x30(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0x10a60
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x80a70
movq %rax, (%rsp)
jmp 0xccef0
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x80ab0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x80a50
testb $0x1, %al
jne 0xccf20
jmp 0xccf32
movb $0x0, 0xd7(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xccf54
jmp 0xccf34
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0xcceaa
movb $0x1, 0xd7(%rsp)
movl $0x1, 0x44(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x6f180
movb 0xd7(%rsp), %al
andb $0x1, %al
addq $0xd8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x8670
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdx, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdi, %rax
movq 0x38(%rsp), %rdi
movq %rax, 0x48(%rsp)
movq %rax, %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0xa0(%rsp)
movq %rdi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
callq 0x1cc40
movq 0x38(%rsp), %rdi
movq %rax, 0x88(%rsp)
callq 0x1cac0
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xe9920
movq 0x40(%rsp), %rdi
callq 0x1cc40
movq 0x40(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0x1cac0
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xe9920
movq 0x48(%rsp), %rdi
movb $0x0, 0x6f(%rsp)
callq 0x18ae0
movl $0x0, 0x68(%rsp)
movl $0x0, 0x64(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x1cd80
movq 0x20(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x2f(%rsp)
jae 0xe2b8b
movq 0x40(%rsp), %rdi
movslq 0x64(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x1cd80
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0xe2b98
jmp 0xe2c72
movq 0x38(%rsp), %rdi
movslq 0x68(%rsp), %rsi
callq 0x8ee50
movq 0x40(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movslq 0x64(%rsp), %rsi
callq 0x8ee50
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq (%rcx), %rax
jae 0xe2bdb
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0xe2c6d
movq 0x38(%rsp), %rdi
movslq 0x68(%rsp), %rsi
callq 0x8ee50
movq 0x40(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movslq 0x64(%rsp), %rsi
callq 0x8ee50
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq (%rcx), %rax
jbe 0xe2c1b
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0xe2c6b
movq 0x38(%rsp), %rdi
movslq 0x68(%rsp), %rsi
callq 0x8ee50
movq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x186f0
jmp 0xe2c39
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0xe2c6b
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x49360
jmp 0xe2c95
jmp 0xe2c6d
jmp 0xe2b3e
movb $0x1, 0x6f(%rsp)
testb $0x1, 0x6f(%rsp)
jne 0xe2c88
movq 0x48(%rsp), %rdi
callq 0x49360
movq 0x30(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x8670
nop
// File: luooofan[P]hblzbd_compiler/src/Pass/loop_unroll.cpp
// Function: add_scope_id(IRFunction*)
void add_scope_id(IRFunction* func) {
  for (auto& bb : func->bb_list_) {
    for (auto& ir : bb->ir_list_) {
      vector<ir::Opn*> tmp;
      tmp.push_back(&ir->opn1_), tmp.push_back(&ir->opn2_), tmp.push_back(&ir->res_);
      for (auto& opn : tmp) {
        if (opn->type_ == ir::Opn::Type::Var) opn->name_ += "_#" + to_string(opn->scope_id_);
      }
    }
  }
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
addq $0x30, %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x1cc40
movq %rax, 0xe0(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x1cac0
movq %rax, 0xd8(%rsp)
leaq 0xe0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x492e0
testb $0x1, %al
jne 0xe350b
jmp 0xe378c
leaq 0xe0(%rsp), %rdi
callq 0x49320
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x1b070
movq %rax, 0xc0(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x1aeb0
movq %rax, 0xb8(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x493c0
testb $0x1, %al
jne 0xe357f
jmp 0xe3778
leaq 0xc0(%rsp), %rdi
callq 0x1b4d0
movq %rax, 0xb0(%rsp)
leaq 0x98(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xc9eb0
movq 0x8(%rsp), %rdi
movq 0xb0(%rsp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, 0x90(%rsp)
leaq 0x90(%rsp), %rsi
callq 0xe99f0
jmp 0xe35d1
movq 0xb0(%rsp), %rax
movq (%rax), %rax
addq $0x48, %rax
movq %rax, 0x78(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xe99f0
jmp 0xe35f9
movq 0xb0(%rsp), %rax
movq (%rax), %rax
addq $0x88, %rax
movq %rax, 0x70(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xe99f0
jmp 0xe3623
leaq 0x98(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0xca5a0
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0xca420
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xe9a20
testb $0x1, %al
jne 0xe3666
jmp 0xe374a
leaq 0x60(%rsp), %rdi
callq 0xe9a60
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
jne 0xe3739
movq 0x50(%rsp), %rax
movq (%rax), %rax
movl 0x28(%rax), %esi
leaq 0x10(%rsp), %rdi
callq 0xc7b0
jmp 0xe369d
leaq 0x1a43e(%rip), %rsi     # 0xfdae2
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xc970
jmp 0xe36b5
movq 0x50(%rsp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
leaq 0x30(%rsp), %rsi
callq 0x84b0
jmp 0xe36cd
leaq 0x30(%rsp), %rdi
callq 0x8728
leaq 0x10(%rsp), %rdi
callq 0x8728
jmp 0xe3739
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xe3769
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xe372d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x8728
leaq 0x10(%rsp), %rdi
callq 0x8728
jmp 0xe3769
jmp 0xe373b
leaq 0x60(%rsp), %rdi
callq 0xe9b10
jmp 0xe364e
leaq 0x98(%rsp), %rdi
callq 0x92a70
leaq 0xc0(%rsp), %rdi
callq 0x49460
jmp 0xe3561
leaq 0x98(%rsp), %rdi
callq 0x92a70
jmp 0xe3794
jmp 0xe377a
leaq 0xe0(%rsp), %rdi
callq 0x49330
jmp 0xe34ed
addq $0xf8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x8670
nopw %cs:(%rax,%rax)