LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: luooofan[P]hblzbd_compiler/src/Pass/loop_unroll.cpp
// Function: del_scope_id(IRFunction*)
void del_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) {
          while (opn->name_[opn->name_.size() - 1] != '_') opn->name_.pop_back();
          opn->name_.pop_back();
        }
      }
    }
  }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
addq $0x30, %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x1cc40
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x1cac0
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x492e0
testb $0x1, %al
jne 0xe381b
jmp 0xe3a3b
leaq 0xb0(%rsp), %rdi
callq 0x49320
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rdi
callq 0x1b070
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rdi
callq 0x1aeb0
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x493c0
testb $0x1, %al
jne 0xe388f
jmp 0xe3a27
leaq 0x90(%rsp), %rdi
callq 0x1b4d0
movq %rax, 0x80(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xc9eb0
movq 0x18(%rsp), %rdi
movq 0x80(%rsp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0xe99f0
jmp 0xe38d8
movq 0x80(%rsp), %rax
movq (%rax), %rax
addq $0x48, %rax
movq %rax, 0x48(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xe99f0
jmp 0xe38fd
movq 0x80(%rsp), %rax
movq (%rax), %rax
addq $0x88, %rax
movq %rax, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xe99f0
jmp 0xe3924
leaq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0xca5a0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0xca420
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xe9a20
testb $0x1, %al
jne 0xe3964
jmp 0xe3a0b
leaq 0x30(%rsp), %rdi
callq 0xe9a60
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
jne 0xe39fa
jmp 0xe3982
movq 0x20(%rsp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0x8280
movq 0x8(%rsp), %rdi
movq %rax, %rsi
decq %rsi
callq 0x8710
movq %rax, 0x10(%rsp)
jmp 0xe39af
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
je 0xe39e9
movq 0x20(%rsp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8470
jmp 0xe3982
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x92a70
jmp 0xe3a43
movq 0x20(%rsp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8470
jmp 0xe39fc
leaq 0x30(%rsp), %rdi
callq 0xe9b10
jmp 0xe394c
leaq 0x68(%rsp), %rdi
callq 0x92a70
leaq 0x90(%rsp), %rdi
callq 0x49460
jmp 0xe3871
jmp 0xe3a29
leaq 0xb0(%rsp), %rdi
callq 0x49330
jmp 0xe37fd
addq $0xc8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x8670
nopl (%rax)
// File: luooofan[P]hblzbd_compiler/src/Pass/loop_unroll.cpp
// Function: find_loop(std::pair<IRBasicBlock*, IRBasicBlock*>)
vector<IRBasicBlock*> find_loop(pair<IRBasicBlock*, IRBasicBlock*> edge) {
  auto &u = edge.first, v = edge.second;
  vector<IRBasicBlock*> res;
  res.push_back(v);
  if (u == v) return res;
  queue<IRBasicBlock*> q;
  q.push(u);
  while (!q.empty()) {
    auto x = q.front();
    q.pop();
    if (have(x, res)) continue;
    res.push_back(x);
    for (auto& pre : x->pred_) q.push(pre);
  }
  return res;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf0(%rsp)
movq %rdx, 0xf8(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0xe0(%rsp)
movb $0x0, 0xdf(%rsp)
callq 0x18ae0
movq 0x30(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x186f0
jmp 0xe42bd
movq 0xe8(%rsp), %rax
movq (%rax), %rax
cmpq 0xe0(%rsp), %rax
jne 0xe4303
movb $0x1, 0xdf(%rsp)
movl $0x1, 0xc8(%rsp)
jmp 0xe44a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0xe44c4
leaq 0x78(%rsp), %rdi
callq 0xe9f60
jmp 0xe430f
movq 0xe8(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0xe9f90
jmp 0xe4323
jmp 0xe4325
leaq 0x78(%rsp), %rdi
callq 0xe9fc0
movb %al, 0x27(%rsp)
jmp 0xe4335
movb 0x27(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe4344
jmp 0xe4478
leaq 0x78(%rsp), %rdi
callq 0xe9fe0
movq %rax, 0x18(%rsp)
jmp 0xe4355
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xe9ff0
jmp 0xe436e
movq 0x30(%rsp), %rsi
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xe9ca0
jmp 0xe4389
movq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xe9df0
movb %al, 0xf(%rsp)
jmp 0xe439e
leaq 0x58(%rsp), %rdi
callq 0x49360
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xe43b2
jmp 0xe43f3
jmp 0xe4325
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0xe4497
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x49360
jmp 0xe4497
movq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x186f0
jmp 0xe4404
movq 0x70(%rsp), %rax
addq $0x28, %rax
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 0xe4445
jmp 0xe4473
leaq 0x48(%rsp), %rdi
callq 0x49320
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0xe9f90
jmp 0xe4465
jmp 0xe4467
leaq 0x48(%rsp), %rdi
callq 0x49330
jmp 0xe4430
jmp 0xe4325
movb $0x1, 0xdf(%rsp)
movl $0x1, 0xc8(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xea000
jmp 0xe44a3
leaq 0x78(%rsp), %rdi
callq 0xea000
jmp 0xe44c4
testb $0x1, 0xdf(%rsp)
jne 0xe44b7
movq 0x30(%rsp), %rdi
callq 0x49360
movq 0x28(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
movq 0x30(%rsp), %rdi
callq 0x49360
movq 0xd0(%rsp), %rdi
callq 0x8670
nopl (%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rdi, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0xf2390
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
callq 0xf23c0
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xf23f0
testb $0x1, %al
jne 0xef0cf
jmp 0xef1f7
leaq 0xb0(%rsp), %rdi
callq 0xf2410
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xf2430
movq 0x10(%rsp), %rsi
movq 0x5ceb6(%rip), %rdi     # 0x14bfb0
callq 0x8310
movq %rax, 0x18(%rsp)
jmp 0xef106
movq 0x18(%rsp), %rdi
leaq 0xc16e(%rip), %rsi      # 0xfb280
callq 0x8330
movq %rax, 0x8(%rsp)
jmp 0xef11e
leaq 0x70(%rsp), %rdi
callq 0x84590
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x8100
movq %rax, (%rsp)
jmp 0xef13b
movq (%rsp), %rdi
movq 0x5ce3a(%rip), %rsi     # 0x14bf80
callq 0x8380
jmp 0xef14d
leaq 0x50(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x845a0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0xf2490
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf24c0
testb $0x1, %al
jne 0xef18e
jmp 0xef1db
leaq 0x30(%rsp), %rdi
callq 0x845d0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x5cdc4(%rip), %rsi     # 0x14bf70
callq 0x441d0
jmp 0xef1b3
jmp 0xef1b5
leaq 0x30(%rsp), %rdi
callq 0xf24e0
jmp 0xef179
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x49870
jmp 0xef1ff
leaq 0x50(%rsp), %rdi
callq 0x49870
leaq 0xb0(%rsp), %rdi
callq 0xf2510
jmp 0xef0b1
addq $0xc8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x8670
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0xf10d9
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0xf10d2
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x1a650
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0xf10af
jmp 0xf10c6
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
cmpl 0x28(%rcx), %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0xf10de
movb $0x0, 0x37(%rsp)
jmp 0xf10de
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq %rdx, 0xc8(%rsp)
movq 0xd8(%rsp), %rdi
addq $0x8, %rdi
callq 0x1b070
movq %rax, 0xb8(%rsp)
movq 0xd8(%rsp), %rdi
addq $0x8, %rdi
callq 0x1aeb0
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0xa3dc0
movq %rax, 0xc0(%rsp)
leaq 0xc0(%rsp), %rdi
movl $0x1, %esi
callq 0x1b480
movq %rax, 0xa8(%rsp)
movq 0xd8(%rsp), %rdi
addq $0x8, %rdi
callq 0x1b070
movq %rax, 0x98(%rsp)
leaq 0x98(%rsp), %rdi
movl $0x1, %esi
callq 0x1b480
movq %rax, 0xa0(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x493c0
testb $0x1, %al
jne 0xf11d1
jmp 0xf1287
leaq 0xa8(%rsp), %rdi
callq 0x1b4d0
movq (%rax), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rsi
addq $0x88, %rsi
leaq 0x50(%rsp), %rdi
callq 0x43130
movq 0xc8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x43130
jmp 0xf1216
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf1060
movb %al, 0x3(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x1f210
leaq 0x50(%rsp), %rdi
callq 0x1f210
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0xf1247
jmp 0xf1273
movq 0x90(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0xf1293
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x8(%rsp)
movl %eax, 0x4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1f210
jmp 0xf12a3
jmp 0xf1275
leaq 0xa8(%rsp), %rdi
callq 0xd6640
jmp 0xf1180
movq $0x0, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x8670
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0xf72c1
movq 0x28(%rsp), %rdi
leaq 0x5332e(%rip), %rsi     # 0x14a5d8
leaq 0x53d87(%rip), %rdx     # 0x14b038
xorl %eax, %eax
movl %eax, %ecx
callq 0x8410
movq %rax, 0x18(%rsp)
jmp 0xf72ca
xorl %eax, %eax
movq %rax, 0x18(%rsp)
jmp 0xf72ca
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0xf734f
movq 0x78(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1d3c0
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1d240
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x49210
testb $0x1, %al
jne 0xf731d
jmp 0xf734a
leaq 0x68(%rsp), %rdi
callq 0x49250
movq 0x20(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rsi
callq 0xf7480
leaq 0x68(%rsp), %rdi
callq 0x49260
jmp 0xf7308
jmp 0xf746e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xf7389
movq 0x10(%rsp), %rdi
leaq 0x53266(%rip), %rsi     # 0x14a5d8
leaq 0x545d7(%rip), %rdx     # 0x14b950
xorl %eax, %eax
movl %eax, %ecx
callq 0x8410
movq %rax, 0x8(%rsp)
jmp 0xf7392
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xf7392
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0xf7415
movq 0x50(%rsp), %rdi
callq 0xa0ee0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x624d0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x62500
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x62530
testb $0x1, %al
jne 0xf73e6
jmp 0xf7413
leaq 0x40(%rsp), %rdi
callq 0x62550
movq 0x20(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
callq 0xf7930
leaq 0x40(%rsp), %rdi
callq 0x62570
jmp 0xf73d1
jmp 0xf746c
movq 0x54bcc(%rip), %rdi     # 0x14bfe8
leaq 0x2cd5(%rip), %rsi      # 0xfa0f8
callq 0x8330
movq %rax, %rdi
leaq 0x67da(%rip), %rsi      # 0xfdc0c
callq 0x8330
movq %rax, %rdi
leaq 0x3fa9(%rip), %rsi      # 0xfb3ea
callq 0x8330
movq %rax, %rdi
movl $0x16, %esi
callq 0x8650
movq %rax, %rdi
movq 0x54b23(%rip), %rsi     # 0x14bf80
callq 0x8380
movl $0xff, %edi
callq 0x8460
jmp 0xf746e
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/End.cpp
// Function: End::responseForOnlyOne()
void End::responseForOnlyOne()
{
    if (_setTime != _time)
	return;
    if(preamble[_preamble] == 1) {
	//probability base on the retransmission
	preamble[_preamble] = setProbablity(_index);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl (%rax), %eax
leaq 0x61aa3(%rip), %rcx     # 0x652e0
cmpl (%rcx), %eax
je 0x3843
jmp 0x387e
movq -0x10(%rbp), %rcx
leaq 0x61fb2(%rip), %rax     # 0x65800
movq (%rax), %rax
movslq 0x4(%rcx), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x387e
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x4b50
movq -0x10(%rbp), %rcx
movl %eax, %edx
leaq 0x61f8c(%rip), %rax     # 0x65800
movq (%rax), %rax
movslq 0x4(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x30b0
movl $0x5, %ecx
cltd
idivl %ecx
movq -0x18(%rbp), %rax
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movl 0x14(%rax), %edi
callq 0x4b50
cmpl $0x1, %eax
jne 0x3adb
callq 0x30b0
movl $0x30, %ecx
cltd
idivl %ecx
movq -0x18(%rbp), %rax
addl $0x1, %edx
movl %edx, -0x10(%rbp)
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
leaq 0x61d70(%rip), %rcx     # 0x6580c
movl (%rcx), %edx
addl $0x1, %edx
leaq 0x61d64(%rip), %rcx     # 0x6580c
movl %edx, (%rcx)
leaq 0x61d57(%rip), %rcx     # 0x65808
movl (%rcx), %edx
addl $0x1, %edx
leaq 0x61d4b(%rip), %rcx     # 0x65808
movl %edx, (%rcx)
leaq 0x6181a(%rip), %rcx     # 0x652e0
movl (%rcx), %ecx
movl -0xc(%rbp), %edx
addl $0x3, %edx
addl %edx, %ecx
addl -0x10(%rbp), %ecx
movl %ecx, 0x8(%rax)
jmp 0x3b69
movl -0xc(%rbp), %eax
addl $0x3, %eax
leaq 0x617f0(%rip), %rcx     # 0x652d8
addl (%rcx), %eax
movl %eax, -0x1c(%rbp)
callq 0x30b0
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdi
leaq 0x617d0(%rip), %rcx     # 0x652d0
cltd
idivl (%rcx)
addl %edx, %esi
callq 0x3b70
movl %eax, %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movl 0x14(%rax), %eax
leaq 0x617a5(%rip), %rcx     # 0x652cc
cmpl (%rcx), %eax
jle 0x3b67
movq -0x18(%rbp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
leaq 0x61ccc(%rip), %rcx     # 0x65808
movl (%rcx), %edx
addl $0x1, %edx
leaq 0x61cc0(%rip), %rcx     # 0x65808
movl %edx, (%rcx)
leaq 0x6178f(%rip), %rcx     # 0x652e0
movl (%rcx), %ecx
movl -0xc(%rbp), %edx
addl $0x3, %edx
addl %edx, %ecx
leaq 0x61776(%rip), %rdx     # 0x652d8
addl (%rdx), %ecx
movl %ecx, 0x8(%rax)
jmp 0x3b69
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mouda[P]LTE_random_access-simulate/parse.cpp
// Function: showHelp()
void showHelp() {
  cout << "-help: print out the help message. "                         <<endl; 
  cout << "-end : specify the number of the Ends   "                    <<endl; 
  cout << "-rand: specify the number of random backoff index"           <<endl; 
  cout << "-type: specify the traffic type, uniform or Beta distribtion"<<endl; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x61415(%rip), %rdi     # 0x64fd0
leaq 0x51456(%rip), %rsi     # 0x55018
callq 0x32e0
movq %rax, %rdi
movq 0x613ef(%rip), %rsi     # 0x64fc0
callq 0x3310
movq 0x613f3(%rip), %rdi     # 0x64fd0
leaq 0x51458(%rip), %rsi     # 0x5503c
callq 0x32e0
movq %rax, %rdi
movq 0x613cd(%rip), %rsi     # 0x64fc0
callq 0x3310
movq 0x613d1(%rip), %rdi     # 0x64fd0
leaq 0x5145f(%rip), %rsi     # 0x55065
callq 0x32e0
movq %rax, %rdi
movq 0x613ab(%rip), %rsi     # 0x64fc0
callq 0x3310
movq 0x613af(%rip), %rdi     # 0x64fd0
leaq 0x5146f(%rip), %rsi     # 0x55097
callq 0x32e0
movq %rax, %rdi
movq 0x61389(%rip), %rsi     # 0x64fc0
callq 0x3310
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x2, 0x60d89(%rip)     # 0x652dc
jne 0x45a6
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x60d5f(%rip), %eax     # 0x652c4
jge 0x45a1
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
callq 0x30b0
movq -0x20(%rbp), %rdi
movl $0x2ee0, %ecx           # imm = 0x2EE0
cltd
idivl %ecx
imull $0x5, %edx, %esi
addl $0x1, %esi
callq 0x4d90
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x455c
jmp 0x462b
cmpl $0x3, 0x60d2f(%rip)     # 0x652dc
jne 0x4629
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x60d05(%rip), %eax     # 0x652c4
jge 0x4627
callq 0x30b0
cvtsi2sd %eax, %xmm0
movsd 0x50bee(%rip), %xmm1    # 0x551c0
divsd %xmm1, %xmm0
movsd 0x50bd2(%rip), %xmm1    # 0x551b0
movsd 0x50bd2(%rip), %xmm2    # 0x551b8
callq 0x4bf0
movaps %xmm0, %xmm1
movsd 0x50bb2(%rip), %xmm0    # 0x551a8
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
imull $0x5, -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x4d90
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x45b6
jmp 0x4629
jmp 0x462b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x60c68(%rip), %eax     # 0x652c0
jge 0x46aa
movq 0x6119f(%rip), %rax     # 0x65800
movslq -0x4(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jle 0x469d
movl $0x1, %edi
callq 0x4b50
cmpl $0x0, %eax
jne 0x469b
movq 0x6117f(%rip), %rax     # 0x65800
movslq -0x4(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x6116a(%rip), %eax     # 0x657fc
addl $0x1, %eax
movl %eax, 0x61161(%rip)     # 0x657fc
jmp 0x469d
jmp 0x469f
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x464f
addq $0x10, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq 0x60908(%rip), %rdi     # 0x64fd0
leaq 0x50ac5(%rip), %rsi     # 0x55194
callq 0x32e0
movq %rax, %rdi
leaq 0x50c53(%rip), %rsi     # 0x55331
callq 0x32e0
movq %rax, %rdi
leaq 0x50aa7(%rip), %rsi     # 0x55194
callq 0x32e0
movq %rax, %rdi
movl -0x4(%rbp), %esi
addl $0x1, %esi
callq 0x34a0
movq %rax, %rdi
leaq 0x50a8a(%rip), %rsi     # 0x55194
callq 0x32e0
movq %rax, %rdi
leaq 0x50c21(%rip), %rsi     # 0x5533a
callq 0x32e0
movq %rax, %rdi
leaq 0x50a6c(%rip), %rsi     # 0x55194
callq 0x32e0
movq %rax, %rdi
movl -0x8(%rbp), %esi
subl -0xc(%rbp), %esi
callq 0x34a0
movq %rax, %rdi
leaq 0x50a4f(%rip), %rsi     # 0x55194
callq 0x32e0
movq %rax, %rdi
leaq 0x50bec(%rip), %rsi     # 0x55340
callq 0x32e0
movq %rax, %rdi
leaq 0x50a31(%rip), %rsi     # 0x55194
callq 0x32e0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x34a0
movq %rax, %rdi
leaq 0x50a17(%rip), %rsi     # 0x55194
callq 0x32e0
movq %rax, %rdi
leaq 0x50bbc(%rip), %rsi     # 0x55348
callq 0x32e0
movq %rax, %rdi
leaq 0x509f9(%rip), %rsi     # 0x55194
callq 0x32e0
movq %rax, %rdi
movl 0x61053(%rip), %esi     # 0x657fc
callq 0x34a0
movq %rax, %rdi
movq 0x60808(%rip), %rsi     # 0x64fc0
callq 0x3310
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
cvtsi2sdl -0x8(%rbp), %xmm0
movsd 0x50668(%rip), %xmm1    # 0x551d0
mulsd %xmm1, %xmm0
callq 0x34f0
movaps %xmm0, %xmm1
movsd 0x5048c(%rip), %xmm0    # 0x55008
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x5063b(%rip), %xmm0    # 0x551c8
mulsd -0x10(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movsd 0x50467(%rip), %xmm0    # 0x55008
subsd -0x10(%rbp), %xmm0
movsd 0x5061a(%rip), %xmm1    # 0x551c8
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
callq 0x30b0
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x4bdb
movl $0x1, -0x4(%rbp)
jmp 0x4be2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x4ed0
movsd %xmm0, -0x78(%rbp)
jmp 0x4de2
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0x4df7
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x4e69
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0x4e4d
movq -0x88(%rbp), %rdi
leaq 0x5fd1d(%rip), %rsi     # 0x64b78
leaq 0x1894e(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0x4eca
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x4eca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x4e8c
jmp 0x4eb9
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0x4eb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rsi
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rdi
callq 0x5530
movsd %xmm0, -0x80(%rbp)
jmp 0x5440
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0x5455
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x54c7
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0x54ab
movq -0x90(%rbp), %rdi
leaq 0x5f6bf(%rip), %rsi     # 0x64b78
leaq 0x182f0(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0x5528
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x5528
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x54ea
jmp 0x5517
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x5512
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x5d40
movsd %xmm0, -0x78(%rbp)
jmp 0x5c52
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0x5c67
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x5cd9
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0x5cbd
movq -0x88(%rbp), %rdi
leaq 0x5eead(%rip), %rsi     # 0x64b78
leaq 0x17ade(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0x5d3a
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x5d3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x5cfc
jmp 0x5d29
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0x5d24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x6100
movsd %xmm0, -0x78(%rbp)
jmp 0x6012
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0x6027
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x6099
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0x607d
movq -0x88(%rbp), %rdi
leaq 0x5eaed(%rip), %rsi     # 0x64b78
leaq 0x1771e(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0x60fa
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x60fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x60bc
jmp 0x60e9
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0x60e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x6560
movsd %xmm0, -0x78(%rbp)
jmp 0x6472
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0x6487
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x64f9
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0x64dd
movq -0x88(%rbp), %rdi
leaq 0x5e68d(%rip), %rsi     # 0x64b78
leaq 0x172be(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0x655a
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x655a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x651c
jmp 0x6549
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0x6544
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x66e0
movsd %xmm0, -0x78(%rbp)
jmp 0x65f2
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0x6607
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x6679
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0x665d
movq -0x88(%rbp), %rdi
leaq 0x5e50d(%rip), %rsi     # 0x64b78
leaq 0x1713e(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0x66da
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x66da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x669c
jmp 0x66c9
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0x66c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x6870
movsd %xmm0, -0x78(%rbp)
jmp 0x6782
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0x6797
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x6809
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0x67ed
movq -0x88(%rbp), %rdi
leaq 0x5e37d(%rip), %rsi     # 0x64b78
leaq 0x16fae(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0x686a
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x686a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0x682c
jmp 0x6859
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0x6854
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x7240
movsd %xmm0, -0x80(%rbp)
jmp 0x7152
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0x7167
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x71d9
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0x71bd
movq -0x90(%rbp), %rdi
leaq 0x5d9ad(%rip), %rsi     # 0x64b78
leaq 0x165de(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0x723a
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x723a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x71fc
jmp 0x7229
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x7224
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::incompletegammac(double, double)
double incompletegammac(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::incompletegammac(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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x7580
movsd %xmm0, -0x80(%rbp)
jmp 0x7492
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0x74a7
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x7519
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0x74fd
movq -0x90(%rbp), %rdi
leaq 0x5d66d(%rip), %rsi     # 0x64b78
leaq 0x1629e(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0x757a
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x757a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x753c
jmp 0x7569
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x7564
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::invincompletegammac(double, double)
double invincompletegammac(const double a, const double y0)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::invincompletegammac(a, 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3ae90
movq -0x88(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x7b10
movsd %xmm0, -0x80(%rbp)
jmp 0x7a22
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ab70
jmp 0x7a37
movsd -0x68(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x7aa9
movq -0x70(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x42660
jmp 0x7a8d
movq -0x90(%rbp), %rdi
leaq 0x5d0dd(%rip), %rsi     # 0x64b78
leaq 0x15d0e(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0x7b0a
movq -0x70(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x7b0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
jmp 0x7acc
jmp 0x7af9
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x31e0
jmp 0x7af4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x3460
movq -0x70(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::airy(double, double&, double&, double&, double&)
void airy(const double x, double &ai, double &aip, double &bi, double &bip)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        alglib_impl::airy(x, &ai, &aip, &bi, &bip, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return;
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3ae90
movq -0x90(%rbp), %r8
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x82c0
jmp 0x81c3
leaq -0x78(%rbp), %rdi
callq 0x3ab70
jmp 0x81ce
jmp 0x829b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
movl -0x84(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x8240
movq -0x80(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x88(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x30(%rbp), %rsi
callq 0x42660
jmp 0x8224
movq -0x98(%rbp), %rdi
leaq 0x5c946(%rip), %rsi     # 0x64b78
leaq 0x15577(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0x82b5
movq -0x80(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0x82b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x3460
jmp 0x8266
jmp 0x82a4
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x31e0
jmp 0x8294
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x3460
jmp 0x82a4
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw %cs:(%rax,%rax)
// File: mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besselj1(double)
double besselj1(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besselj1(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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3ae90
movq -0x80(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0xa3e0
movsd %xmm0, -0x78(%rbp)
jmp 0xa2f2
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3ab70
jmp 0xa307
movsd -0x60(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xa379
movq -0x68(%rbp), %rdi
callq 0x30f0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x42660
jmp 0xa35d
movq -0x88(%rbp), %rdi
leaq 0x5a80d(%rip), %rsi     # 0x64b78
leaq 0x1343e(%rip), %rdx     # 0x1d7b0
callq 0x3490
jmp 0xa3da
movq -0x68(%rbp), %rdi
callq 0x30f0
callq 0x3420
jmp 0xa3da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
jmp 0xa39c
jmp 0xa3c9
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31e0
jmp 0xa3c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3460
movq -0x68(%rbp), %rdi
callq 0x34c0
movq %rax, %rdi
callq 0x1d7a0
nopw (%rax,%rax)