LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x54365
movl %ecx, %ebp
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %r8
xorl %r10d, %r10d
movq %rdx, %rax
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x54283
movq (%rax), %r9
movq %rax, %r10
cmpq %rcx, 0x8(%r9)
je 0x54283
movq %rdx, %rsi
movq %r9, %r11
movq (%r9), %r9
testq %r9, %r9
je 0x54280
movq 0x8(%r9), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %r10d
cmpq %rsi, %rdx
jne 0x54283
movq %r11, %r10
cmpq %rcx, %rdi
jne 0x54254
jmp 0x54283
xorl %r10d, %r10d
testq %r10, %r10
je 0x5428e
cmpq $0x0, (%r10)
jne 0x54308
leaq 0x8(%rsp), %rdx
movq %r14, (%rdx)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3632c
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 0x542e5
movq 0x10(%r12), %rdx
testq %rdx, %rdx
je 0x54315
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x54206
movq (%r12), %r12
jmp 0x542c0
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x542fd
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x54308
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x45f52
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3bcd4(%rip), %rdi     # 0x8fff0
leaq 0x1ae45(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x1e5e8(%rip), %rsi     # 0x72917
movq %rax, %rdi
callq 0x8280
leaq 0x1c082(%rip), %rsi     # 0x703c0
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 0x3bc84(%rip), %rdi     # 0x8fff0
leaq 0x1adf5(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x1e598(%rip), %rsi     # 0x72917
movq %rax, %rdi
callq 0x8280
leaq 0x1c032(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x17f, %esi            # imm = 0x17F
jmp 0x5434e
// File: /workspace/github_cpp_makefile_star2_O1/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 0x543f7
movq 0x30(%rsi), %rax
movq 0x10(%rax), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x54206
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 0x5443a
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 0x5441c
movq %rsp, %rdi
callq 0x362bc
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x362bc
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5446c
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x82a0
movq %r14, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O1/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 0x58c5a
movq 0x10(%r14), %rdx
cmpq 0x10(%rbx), %rdx
jne 0x58c6f
testq %rdx, %rdx
je 0x58c4d
movq 0x8(%rbx), %rsi
movq 0x8(%r14), %rdi
callq 0x82b0
testl %eax, %eax
jne 0x58c6f
movl 0x28(%r14), %ecx
movb $0x1, %al
cmpl 0x28(%rbx), %ecx
jne 0x58c6f
jmp 0x58c71
xorl %eax, %ecx
xorl $0x1, %eax
orl %ecx, %eax
jne 0x58c6f
movl 0x4(%r14), %eax
cmpl 0x4(%rbx), %eax
sete %al
jmp 0x58c71
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
setne %bpl
je 0x5a568
movq %rsi, %rbx
movq 0x10(%rsi), %r15
movq 0x8(%r14), %r12
movq 0x10(%r12), %rdx
cmpq %r15, %rdx
jne 0x5a55c
testq %rdx, %rdx
je 0x5a552
movq 0x8(%rbx), %rsi
movq 0x8(%r12), %rdi
callq 0x82b0
testl %eax, %eax
jne 0x5a55c
movl 0x28(%r12), %eax
cmpl 0x28(%rbx), %eax
je 0x5a568
movq (%r14), %r14
testq %r14, %r14
setne %bpl
jne 0x5a52d
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a9ff
leaq 0x33c29(%rip), %rsi     # 0x8e618
leaq 0x34682(%rip), %rdx     # 0x8f078
xorl %ecx, %ecx
callq 0x8320
jmp 0x5aa01
xorl %eax, %eax
testq %rax, %rax
je 0x5aa29
movq 0x28(%rax), %rbx
movq 0x30(%rax), %r14
cmpq %r14, %rbx
je 0x5aa21
movq (%rbx), %rdi
callq 0x5a6b2
addq $0x8, %rbx
jmp 0x5aa0e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x355c0(%rip), %rdi     # 0x8fff0
leaq 0x14731(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x18002(%rip), %rsi     # 0x72a45
movq %rax, %rdi
callq 0x8280
leaq 0x1596e(%rip), %rsi     # 0x703c0
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_O1/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
cmpq %rax, 0x8(%rsi)
je 0x5b56c
movq %rdx, %r14
movq %rsi, %r15
xorl %ecx, %ecx
xorl %ebp, %ebp
xorl %r12d, %r12d
movslq %r12d, %rsi
movq (%r14), %rdi
movq 0x8(%r14), %rdx
subq %rdi, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x5b56c
movl (%rax,%rcx,4), %edx
cmpl (%rdi,%rsi,4), %edx
jge 0x5b52d
incl %ebp
jmp 0x5b556
jg 0x5b553
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5b545
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5b551
leaq (%rax,%rcx,4), %rdx
movq %rbx, %rdi
callq 0x12d38
incl %ebp
incl %r12d
movslq %ebp, %rcx
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rcx, %rdx
ja 0x5b50b
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5b58f
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x82a0
movq %r14, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b8b0
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
addq %r13, %rsi
movq %r15, %rdi
callq 0x3ac8e
incq %rbp
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
addq $0x8, %r13
cmpq %rbp, %rax
ja 0x5b88b
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sete %bl
je 0x5b92a
sarq $0x2, %rcx
movq 0x18(%rsp), %rdx
cmpq $0x1, %rcx
movq %rcx, %rsi
adcq $0x0, %rsi
xorl %edi, %edi
movq %r12, %r8
testq %rdx, %rdx
je 0x5b900
movl (%rax,%rdi,4), %r9d
movq %rdx, %r10
movq %r12, %r8
xorl %r11d, %r11d
cmpl %r9d, 0x20(%r10)
setl %r11b
cmovgeq %r10, %r8
movq 0x10(%r10,%r11,8), %r10
testq %r10, %r10
jne 0x5b8e7
movq %r12, %r9
cmpq %r12, %r8
je 0x5b917
movl (%rax,%rdi,4), %r9d
cmpl 0x20(%r8), %r9d
cmovlq %r12, %r8
movq %r8, %r9
cmpq %r12, %r9
jne 0x5b92a
incq %rdi
cmpq %rdi, %rcx
setbe %bl
cmpq %rsi, %rdi
jne 0x5b8d5
leaq 0x8(%rsp), %rdi
callq 0x3b482
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 0x3b482
movq %rbx, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq %rsi, 0x8(%rdx)
je 0x5b9dc
movq %rdx, %r14
movq %rdi, %r15
movq %rdi, %rbp
shrq $0x20, %rbp
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpl %r15d, (%rsi,%rbx)
jne 0x5b9b5
cmpl %ebp, 0x4(%rsi,%rbx)
je 0x5b9c2
addq %rbx, %rsi
leaq 0x8(%rsp), %rdi
callq 0x3ac8e
incq %r12
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
addq $0x8, %rbx
cmpq %r12, %rax
ja 0x5b9a9
movq (%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sete %bl
je 0x5ba5a
sarq $0x2, %rcx
movq 0x18(%rsp), %rdx
cmpq $0x1, %rcx
movq %rcx, %rsi
adcq $0x0, %rsi
xorl %edi, %edi
movq %r13, %r8
testq %rdx, %rdx
je 0x5ba30
movl (%rax,%rdi,4), %r9d
movq %rdx, %r10
movq %r13, %r8
xorl %r11d, %r11d
cmpl %r9d, 0x20(%r10)
setl %r11b
cmovgeq %r10, %r8
movq 0x10(%r10,%r11,8), %r10
testq %r10, %r10
jne 0x5ba17
movq %r13, %r9
cmpq %r13, %r8
je 0x5ba47
movl (%rax,%rdi,4), %r9d
cmpl 0x20(%r8), %r9d
cmovlq %r13, %r8
movq %r8, %r9
cmpq %r13, %r9
jne 0x5ba5a
incq %rdi
cmpq %rdi, %rcx
setbe %bl
cmpq %rsi, %rdi
jne 0x5ba05
leaq 0x8(%rsp), %rdi
callq 0x3b482
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 0x3b482
movq %rbx, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O1/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 0x63c25
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 0x68d0d
movq %r12, %rdi
movq %r13, %rsi
callq 0x68df6
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x63c5e
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 0x68d0d
movq %r12, %rdi
movq %r13, %rsi
callq 0x68df6
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x63cdd
xorl %ecx, %ecx
xorl %ebp, %ebp
xorl %r12d, %r12d
movslq %r12d, %rsi
movq (%r14), %rdi
movq 0x8(%r14), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x63cdd
movq (%rax,%rcx,8), %rdx
cmpq (%rdi,%rsi,8), %rdx
jae 0x63ca0
incl %ebp
jmp 0x63cc7
ja 0x63cc4
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x63cb6
movq %rdx, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x63cc2
leaq (%rax,%rcx,8), %rdx
movq %rbx, %rdi
callq 0x11b10
incl %ebp
incl %r12d
movslq %ebp, %rcx
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rcx, %rdx
ja 0x63c7c
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 0x63d06
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x82a0
movq %r14, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O1/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 0x69903
movq %rsp, %r14
movq 0x2677f(%rip), %r15     # 0x8ffc0
leaq 0x6aa8(%rip), %r12      # 0x702f0
movq 0x26731(%rip), %r13     # 0x8ff80
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x6b904
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 0x698d2
movq 0x8(%rbp), %rdi
movq %r13, %rsi
callq 0x29616
movq (%rbp), %rbp
jmp 0x698bb
leaq 0x20(%rsp), %rdi
callq 0x2bade
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x698f7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x82a0
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x6984f
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x69914
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6b98e
movq %rbx, %rdi
callq 0x8540
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6ab71
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 0x6ab9b
testq %rdx, %rdx
je 0x6ab9f
movq 0x8(%rbx), %rsi
movq 0x8(%r14), %rdi
callq 0x82b0
testl %eax, %eax
je 0x6ab9f
xorl %eax, %eax
jmp 0x6aba9
movl 0x28(%r14), %eax
cmpl 0x28(%rbx), %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, (%rsp)
movq %rdi, %rax
leaq 0x10(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x8(%rdi), %rdi
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rsi
callq 0x4af35
movq %rax, %r15
leaq 0x18(%rsp), %rbx
leaq 0x58(%rsp), %rbp
movq 0x8(%rsp), %rax
cmpq 0x8(%rax), %r15
je 0x6ac72
addq $-0x8, %r15
movq (%r15), %r13
leaq 0x88(%r13), %rsi
movq %rbx, %rdi
callq 0x28186
movq %rbp, %rdi
movq (%rsp), %rsi
callq 0x28186
movq %rbp, %rsi
movq %rbx, %r14
movq %rbx, %rdi
callq 0x6ab68
movl %eax, %ebx
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x6ac49
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x82a0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x6ac65
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x82a0
testb %bl, %bl
cmovneq %r13, %r12
movq %r14, %rbx
je 0x6abf0
jmp 0x6ac75
xorl %r12d, %r12d
movq %r12, %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 0x6aca9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x82a0
movq %rbx, %rdi
callq 0x8540
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/Pass/simplify_cfg.cpp
// Function: SimplifyCFG::Run()
void SimplifyCFG::Run() {
  if (auto m = dynamic_cast<IRModule*>(*(this->m_))) {
    //
    for (auto func : m->func_list_) {
      Run4IRFunc(func);
    }
  } else if (auto m = dynamic_cast<SSAModule*>(*(this->m_))) {
    //
    for (auto func : m->GetFuncList()) {
      Run4SSAFunc(func);
    }
  } else {
    MyAssert(0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq (%rax), %rbx
testq %rbx, %rbx
je 0x6cfaa
leaq 0x21681(%rip), %rsi     # 0x8e618
leaq 0x220da(%rip), %rdx     # 0x8f078
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8320
jmp 0x6cfac
xorl %eax, %eax
testq %rax, %rax
je 0x6cfcc
movq 0x28(%rax), %rbx
movq 0x30(%rax), %r14
cmpq %r14, %rbx
je 0x6cfee
movq (%rbx), %rsi
callq 0x6d046
addq $0x8, %rbx
jmp 0x6cfb9
testq %rbx, %rbx
je 0x6cff6
leaq 0x21640(%rip), %rsi     # 0x8e618
leaq 0x22951(%rip), %rdx     # 0x8f930
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
je 0x6cff6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x22ff3(%rip), %rdi     # 0x8fff0
leaq 0x2164(%rip), %rsi      # 0x6f168
callq 0x8280
leaq 0x5c6e(%rip), %rsi      # 0x72c7e
movq %rax, %rdi
callq 0x8280
leaq 0x33a1(%rip), %rsi      # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x16, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/End.cpp
// Function: End::settime()
void End::settime()
{
    if (_setTime != _time)
	return;
    if(preamble[_preamble] == 1) {
	id();// case for success
    }
    else if (preamble[_preamble] > 1){
	int Fwait = rand() % 5 + 1;
	_collision++;
	_setTime += _CountCeil(/*lte::firstWaiting*/ (Fwait + 3) + lte::secondWaiting + rand()%lte::RandomBackoffIndex);
	_index++;
	if(_index > lte::MAX) {
	    _setTime = -2;
	    _finish = _time + (Fwait + 3) + lte::secondWaiting;
	    _count++;
	}
    }else {
	_setTime += _CountCeil(lte::firstWaiting + rand()%lte::RandomBackoffIndex);
	//set the next preamble transmission time
	_index++;
	if(_index > lte::MAX){
	    _count++;
	    _setTime = -2;
	    _finish = _time + lte::firstWaiting;
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rdi), %eax
leaq 0x40b83(%rip), %r14     # 0x44278
cmpl (%r14), %eax
jne 0x383c
movq %rdi, %rbx
leaq 0x40ba8(%rip), %rax     # 0x442b0
movq (%rax), %rax
movslq 0x4(%rdi), %rcx
movl (%rax,%rcx,4), %eax
cmpl $0x1, %eax
jne 0x3727
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3846
jle 0x37ce
callq 0x30b0
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
incl 0xc(%rbx)
negl %ecx
leal (%rax,%rcx), %ebp
addl $0x4, %ebp
leaq 0x40b13(%rip), %r15     # 0x44270
movl (%r15), %r12d
addl %ebp, %r12d
callq 0x30b0
leaq 0x40af9(%rip), %rcx     # 0x44268
cltd
idivl (%rcx)
addl %r12d, %edx
movslq %edx, %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
movl %eax, %edx
subl %ecx, %edx
leal 0x5(%rdx,%rdx,4), %ecx
cmovel %eax, %ecx
addl %ecx, (%rbx)
movl 0x14(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
leaq 0x40ab8(%rip), %rcx     # 0x44264
cmpl (%rcx), %eax
jl 0x383c
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
addl (%r14), %ebp
addl (%r15), %ebp
movl %ebp, 0x8(%rbx)
leaq 0x40aee(%rip), %rax     # 0x442b8
incl (%rax)
jmp 0x383c
leaq 0x40a97(%rip), %r15     # 0x4426c
movl (%r15), %ebp
callq 0x30b0
leaq 0x40a84(%rip), %rcx     # 0x44268
cltd
idivl (%rcx)
addl %ebp, %edx
movslq %edx, %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
movl %eax, %edx
subl %ecx, %edx
leal 0x5(%rdx,%rdx,4), %ecx
cmovel %eax, %ecx
addl %ecx, (%rbx)
movl 0x14(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
leaq 0x40a44(%rip), %rcx     # 0x44264
cmpl (%rcx), %eax
jl 0x383c
leaq 0x40a8d(%rip), %rax     # 0x442b8
incl (%rax)
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
movl (%r15), %eax
addl (%r14), %eax
movl %eax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/End.cpp
// Function: End::id()
void End::id()
{
  int Fwait = rand() % 5 + 1;
  if ( setProbablity(_index) == 1 ) {
    int Swait = rand() % 48 + 1;
    _setTime = -1;
    _goodEnd++;
    _count++;
    _finish = _time + (3 +Fwait) + Swait;
  } else {
	_setTime += _CountCeil(/*lte::firstWaiting*/ (Fwait + 3) + lte::secondWaiting + rand()%lte::RandomBackoffIndex);
	_index++;
	if ( _index > lte::MAX ) {
	    _setTime = -2;
	    _count++;
	    _finish = _time + (3 + Fwait) + lte::secondWaiting;
	}
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x30b0
movslq %eax, %r14
imulq $0x66666667, %r14, %rax # imm = 0x66666667
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rax
addl %ecx, %eax
leal (%rax,%rax,4), %eax
subl %eax, %r14d
movl 0x14(%rbx), %edi
callq 0x489e
cmpl $0x1, %eax
jne 0x38cf
callq 0x30b0
cltq
imulq $0x2aaaaaab, %rax, %rcx # imm = 0x2AAAAAAB
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x23, %rcx
addl %edx, %ecx
shll $0x4, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
leaq 0x40a0d(%rip), %rcx     # 0x442bc
incl (%rcx)
leaq 0x40a00(%rip), %rcx     # 0x442b8
incl (%rcx)
leaq 0x409b7(%rip), %rcx     # 0x44278
movl (%rcx), %ecx
addl %eax, %r14d
addl %ecx, %r14d
addl $0x5, %r14d
jmp 0x3948
addl $0x4, %r14d
leaq 0x40996(%rip), %r15     # 0x44270
movl (%r15), %ebp
addl %r14d, %ebp
callq 0x30b0
leaq 0x4097c(%rip), %rcx     # 0x44268
cltd
idivl (%rcx)
addl %ebp, %edx
movslq %edx, %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
movl %eax, %edx
subl %ecx, %edx
leal 0x5(%rdx,%rdx,4), %ecx
cmovel %eax, %ecx
addl %ecx, (%rbx)
movl 0x14(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
leaq 0x4093c(%rip), %rcx     # 0x44264
cmpl (%rcx), %eax
jl 0x394c
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
leaq 0x4097f(%rip), %rax     # 0x442b8
incl (%rax)
leaq 0x40936(%rip), %rax     # 0x44278
addl (%rax), %r14d
addl (%r15), %r14d
movl %r14d, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/main.cpp
// Function: set_traffic(End*)
void set_traffic(End* end) {
	if (lte::traffic_type == uniform_start) {
		for (int i = 0; i < lte::EndNum; i++) 
			end[i].setStartTime((rand()%12000)*5 + 1);
	}
	/*
	Beta(a,b): a=3 b=4    Beta(3,4) = 1/60
	p(t) = 6/10^5*t^2*(10-t)^3
	access_intensity(i) = EndNum * integral of p(t) from ti to ti+1
	*/
	else if (lte::traffic_type == beta_start) {
		for (int i = 0; i < lte::EndNum; i++) {
			//int setPeriod = (int)floor(2000.0*beta(3.0, 4.0));
			//end[i].setStartTime(setPeriod*5 + 1);
			int setPeriod = (int)(2000.0*betaDistribution((rand() / ((double)RAND_MAX)), 3.0, 4.0));
			end[i].setStartTime(setPeriod*5 + 1);
			//cerr << "!!!!!!!!!!!!!" << betaDistribution((rand() / ((double)RAND_MAX + 1.0)), 3.0, 4.0) << endl;
		}
		
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x3ff62(%rip), %eax     # 0x44274
cmpl $0x2, %eax
je 0x43cd
cmpl $0x3, %eax
jne 0x441d
cmpl $0x0, 0x3ff31(%rip)     # 0x4425c
jle 0x441d
addq $0x10, %rbx
xorl %r14d, %r14d
callq 0x30b0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd 0x2fe4c(%rip), %xmm1    # 0x34198
movsd 0x2fe4c(%rip), %xmm0    # 0x341a0
subsd %xmm1, %xmm0
mulsd %xmm1, %xmm1
movsd %xmm1, (%rsp)
movsd 0x2fe3f(%rip), %xmm1    # 0x341a8
callq 0x3410
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x2fe28(%rip), %xmm0    # 0x341a8
movsd 0x2fe28(%rip), %xmm1    # 0x341b0
callq 0xa200
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
divsd 0x2fe1a(%rip), %xmm1    # 0x341b8
mulsd 0x2fe1a(%rip), %xmm1    # 0x341c0
cvttsd2si %xmm1, %eax
leal (%rax,%rax,4), %eax
incl %eax
movl %eax, -0x10(%rbx)
movl %eax, (%rbx)
incq %r14
movslq 0x3fe9e(%rip), %rax     # 0x4425c
addq $0x18, %rbx
cmpq %rax, %r14
jl 0x4338
jmp 0x441d
cmpl $0x0, 0x3fe88(%rip)     # 0x4425c
jle 0x441d
addq $0x10, %rbx
xorl %r14d, %r14d
callq 0x30b0
cltq
imulq $0x57619f1, %rax, %rcx  # imm = 0x57619F1
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x28, %rcx
addl %edx, %ecx
imull $0x2ee0, %ecx, %ecx     # imm = 0x2EE0
subl %ecx, %eax
leal (%rax,%rax,4), %eax
incl %eax
movl %eax, -0x10(%rbx)
movl %eax, (%rbx)
incq %r14
movslq 0x3fe48(%rip), %rax     # 0x4425c
addq $0x18, %rbx
cmpq %rax, %r14
jl 0x43dd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/main.cpp
// Function: responseForUseSamePreamble()
void responseForUseSamePreamble()
{
    for( int i = 0; i < lte::preambleNum;  i++ ){
	if( preamble[i] > 1 ){
	//preamble[i] = setProbablity(1); 
	    if (setProbablity(1) == 0) { 
		preamble[i] = 0;
		collision_time++;
	    }
	}
  }
}

// Assembly:
cmpl $0x0, 0x3fe2c(%rip)     # 0x44258
jle 0x4470
pushq %rbx
xorl %ebx, %ebx
movq 0x3fe78(%rip), %rax     # 0x442b0
cmpl $0x2, (%rax,%rbx,4)
jl 0x4460
movl $0x1, %edi
callq 0x489e
testl %eax, %eax
jne 0x4460
movq 0x3fe5d(%rip), %rax     # 0x442b0
movl $0x0, (%rax,%rbx,4)
incl 0x3fe4c(%rip)           # 0x442ac
incq %rbx
movslq 0x3fdee(%rip), %rax     # 0x44258
cmpq %rax, %rbx
jl 0x4431
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/main.cpp
// Function: analysisForEvent(int, int, int)
void analysisForEvent(int _time, int _count, int _goodEnd) {
	cout << "\t" << "time(ms)" << "\t" << (_time+1)
	<< "\t" << "abort" << "\t" << (_count-_goodEnd)
	<< "\t" << "success" << "\t" << (_goodEnd)
	<< "\t" << "collision" << "\t" << collision_time
	<< endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movq 0x3fb48(%rip), %r12     # 0x43fd0
leaq 0x2fcf1(%rip), %rbx     # 0x34180
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x32d0
leaq 0x2fe9b(%rip), %rsi     # 0x34341
movl $0x8, %edx
movq %r12, %rdi
callq 0x32d0
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x32d0
incl %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x3400
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32d0
leaq 0x2fe5f(%rip), %rsi     # 0x3434a
movl $0x5, %edx
movq %r15, %rdi
callq 0x32d0
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x32d0
subl %ebp, %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x3400
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32d0
leaq 0x2fe20(%rip), %rsi     # 0x34350
movl $0x7, %edx
movq %r14, %rdi
callq 0x32d0
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32d0
movq %r14, %rdi
movl %ebp, %esi
callq 0x3400
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32d0
leaq 0x2fde7(%rip), %rsi     # 0x34358
movl $0x9, %edx
movq %r14, %rdi
callq 0x32d0
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32d0
movl 0x3fd18(%rip), %esi     # 0x442ac
movq %r14, %rdi
callq 0x3400
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31a0
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/main.cpp
// Function: setProbablity(int)
int setProbablity( int retransmit )
{
 double p = 1 - exp((double) retransmit*(-1));
 int p1 = p*1000;
 int p2 = (1.0 - p)*1000;
 
 int key = rand() % (p1 + p2);
 
 if (key <= p1) return 1;
 else return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cvtsi2sd %edi, %xmm0
xorpd 0x2f933(%rip), %xmm0    # 0x341e0
callq 0x3440
movsd 0x2f8e6(%rip), %xmm1    # 0x341a0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd 0x2f8fe(%rip), %xmm0    # 0x341c8
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %ebx
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %ebp
callq 0x30b0
addl %ebx, %ebp
cltd
idivl %ebp
xorl %eax, %eax
cmpl %ebx, %edx
setle %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::gammafunction(double)
double gammafunction(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::gammafunction(x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x4a30
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x49fc
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3f195(%rip), %rsi     # 0x43b80
leaq 0xee92(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x4a01
callq 0x3360
movq %rax, %rbx
jmp 0x4a11
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x4a20
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::lngamma(double, double&)
double lngamma(const double x, double &sgngam)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::lngamma(x, &sgngam, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x256af
movsd (%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e78
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x4e44
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3ed4d(%rip), %rsi     # 0x43b80
leaq 0xea4a(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x4e49
callq 0x3360
movq %rax, %rbx
jmp 0x4e59
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x4e68
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::errorfunction(double)
double errorfunction(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::errorfunction(x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x53c0
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x538c
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3e805(%rip), %rsi     # 0x43b80
leaq 0xe502(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x5391
callq 0x3360
movq %rax, %rbx
jmp 0x53a1
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x53b0
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::errorfunction(double, alglib_impl::ae_state*)
double errorfunction(double x, ae_state *_state)
{
    double xsq;
    double s;
    double p;
    double q;
    double result;


    s = ae_sign(x, _state);
    x = ae_fabs(x, _state);
    if( ae_fp_less(x,0.5) )
    {
        xsq = x*x;
        p = 0.007547728033418631287834;
        p = 0.288805137207594084924010+xsq*p;
        p = 14.3383842191748205576712+xsq*p;
        p = 38.0140318123903008244444+xsq*p;
        p = 3017.82788536507577809226+xsq*p;
        p = 7404.07142710151470082064+xsq*p;
        p = 80437.3630960840172832162+xsq*p;
        q = 0.0;
        q = 1.00000000000000000000000+xsq*q;
        q = 38.0190713951939403753468+xsq*q;
        q = 658.070155459240506326937+xsq*q;
        q = 6379.60017324428279487120+xsq*q;
        q = 34216.5257924628539769006+xsq*q;
        q = 80437.3630960840172826266+xsq*q;
        result = s*1.1283791670955125738961589031*x*p/q;
        return result;
    }
    if( ae_fp_greater_eq(x,10) )
    {
        result = s;
        return result;
    }
    result = s*(1-errorfunctionc(x, _state));
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd %xmm0, (%rsp)
callq 0x265a0
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x26575
movsd 0x2f073(%rip), %xmm1    # 0x34468
movsd %xmm0, (%rsp)
callq 0x262fe
testb %al, %al
je 0x54d0
movsd (%rsp), %xmm4
movapd %xmm4, %xmm1
mulsd %xmm4, %xmm1
movsd 0x2f134(%rip), %xmm0    # 0x34550
mulsd %xmm1, %xmm0
addsd 0x2f130(%rip), %xmm0    # 0x34558
mulsd %xmm1, %xmm0
addsd 0x2f12c(%rip), %xmm0    # 0x34560
mulsd %xmm1, %xmm0
addsd 0x2f128(%rip), %xmm0    # 0x34568
mulsd %xmm1, %xmm0
addsd 0x2f124(%rip), %xmm0    # 0x34570
mulsd %xmm1, %xmm0
addsd 0x2f120(%rip), %xmm0    # 0x34578
xorpd %xmm2, %xmm2
mulsd %xmm1, %xmm2
addsd 0x2ed38(%rip), %xmm2    # 0x341a0
mulsd %xmm1, %xmm2
addsd 0x2f114(%rip), %xmm2    # 0x34588
mulsd %xmm1, %xmm2
addsd 0x2f110(%rip), %xmm2    # 0x34590
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm2
addsd 0x2f108(%rip), %xmm2    # 0x34598
movsd 0x2f0e8(%rip), %xmm3    # 0x34580
mulsd %xmm1, %xmm2
addsd 0x2f0fc(%rip), %xmm2    # 0x345a0
addsd %xmm3, %xmm0
mulsd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x2f0ee(%rip), %xmm1    # 0x345a8
addsd %xmm3, %xmm2
mulsd %xmm4, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm2, %xmm1
movapd %xmm1, %xmm0
jmp 0x5511
movsd 0x2f070(%rip), %xmm1    # 0x34548
movsd (%rsp), %xmm0
callq 0x2635a
testb %al, %al
je 0x54ee
movsd 0x8(%rsp), %xmm0
jmp 0x5511
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x55cf
movsd 0x2ec9d(%rip), %xmm1    # 0x341a0
subsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::errorfunctionc(double)
double errorfunctionc(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::errorfunctionc(x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x55cf
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x559b
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3e5f6(%rip), %rsi     # 0x43b80
leaq 0xe2f3(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x55a0
callq 0x3360
movq %rax, %rbx
jmp 0x55b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x55bf
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::normaldistribution(double)
double normaldistribution(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::normaldistribution(x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd (%rsp), %xmm0
divsd 0x2eea4(%rip), %xmm0    # 0x34628
movq %rbx, %rdi
callq 0x53c0
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addsd 0x2e9f8(%rip), %xmm0    # 0x341a0
mulsd 0x2ecb8(%rip), %xmm0    # 0x34468
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x57fa
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3e397(%rip), %rsi     # 0x43b80
leaq 0xe094(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x57ff
callq 0x3360
movq %rax, %rbx
jmp 0x580f
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x581e
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::inverf(double)
double inverf(const double e)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::inverf(e, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd 0x8(%rsp), %xmm0
addsd 0x2e92a(%rip), %xmm0    # 0x341a0
mulsd 0x2ebea(%rip), %xmm0    # 0x34468
movq %rbx, %rdi
callq 0x5a37
movsd %xmm0, 0x8(%rsp)
movsd 0x2eb4c(%rip), %xmm0    # 0x343e0
leaq 0x18(%rsp), %rdi
callq 0x2658d
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x25556
movsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x5904
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3e28d(%rip), %rsi     # 0x43b80
leaq 0xdf8a(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x5909
callq 0x3360
movq %rax, %rbx
jmp 0x5919
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x5928
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::invnormaldistribution(double)
double invnormaldistribution(const double y0)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invnormaldistribution(y0, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x5a37
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25556
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x5a03
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3e18e(%rip), %rsi     # 0x43b80
leaq 0xde8b(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x5a08
callq 0x3360
movq %rax, %rbx
jmp 0x5a18
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x5a27
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878
// File: /workspace/github_cpp_makefile_star2_O1/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::incompletegamma(double, double)
double incompletegamma(const double a, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::incompletegamma(a, x, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x256af
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0x5e8e
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x25556
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x5e5a
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x2966e
leaq 0x3dd37(%rip), %rsi     # 0x43b80
leaq 0xda34(%rip), %rdx      # 0x13884
movq %r14, %rdi
callq 0x33f0
jmp 0x5e5f
callq 0x3360
movq %rax, %rbx
jmp 0x5e6f
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x5e7e
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x13878