LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/Pass/reach_define.cpp
// Function: finddef(IRBasicBlock*, ir::IR*, ir::Opn*)
ir::IR *finddef(IRBasicBlock *bb, ir::IR *ir, ir::Opn *opn) {
  auto it = find(bb->ir_list_.begin(), bb->ir_list_.end(), ir);

  for (auto iter = it - 1; iter != bb->ir_list_.begin() - 1; --iter) {
    auto def = *iter;

    if (isSameOpn(def->res_, *opn)) {
      // printf("/*************************\n");
      return def;
    }
  }

  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, %r14
leaq 0x10(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rsi
callq 0x3b017
movq %rax, %r12
leaq 0x18(%rsp), %rbp
leaq 0x58(%rsp), %r15
cmpq 0x8(%r14), %r12
je 0x527ea
addq $-0x8, %r12
movq (%r12), %r13
leaq 0x88(%r13), %rsi
movq %rbp, %rdi
callq 0x1da22
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x1da22
movq %rbp, %rdi
movq %r15, %rsi
callq 0x52724
movl %eax, %ebx
leaq 0x60(%rsp), %rdi
callq 0x8578
leaq 0x20(%rsp), %rdi
callq 0x8578
testb %bl, %bl
je 0x52799
jmp 0x527ed
xorl %r13d, %r13d
movq %r13, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x84d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x541b5
leaq 0x2b4e9(%rip), %rsi     # 0x7f648
leaq 0x2bf0a(%rip), %rdx     # 0x80070
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x82c0
testq %rax, %rax
je 0x54190
movq 0x28(%rax), %rbx
movq 0x30(%rax), %r14
cmpq %r14, %rbx
je 0x541ad
movq (%rbx), %rsi
callq 0x54204
addq $0x8, %rbx
jmp 0x5417d
leaq 0x2b4b1(%rip), %rsi     # 0x7f648
leaq 0x2c762(%rip), %rdx     # 0x80900
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x82c0
testq %rax, %rax
je 0x541b5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2ce2c(%rip), %rdi     # 0x80fe8
leaq 0x1f25(%rip), %rsi      # 0x560e8
callq 0x8240
leaq 0x59f7(%rip), %rsi      # 0x59bc6
movq %rax, %rdi
callq 0x8240
leaq 0x3142(%rip), %rsi      # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x16
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
leaq 0x3dbc0(%rip), %r14     # 0x41268
cmpl (%r14), %eax
jne 0x37b3
movq %rdi, %rbx
leaq 0x3dbe5(%rip), %rax     # 0x412a0
movq (%rax), %rax
movslq 0x4(%rdi), %rcx
movl (%rax,%rcx,4), %eax
cmpl $0x1, %eax
jne 0x36e0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37c2
jle 0x3757
callq 0x30a0
pushq $0x5
popq %r12
cltd
idivl %r12d
movl %edx, %ebp
incl 0xc(%rbx)
addl $0x4, %ebp
leaq 0x3db62(%rip), %r15     # 0x41260
movl (%r15), %r13d
addl %ebp, %r13d
callq 0x30a0
leaq 0x3db48(%rip), %rcx     # 0x41258
cltd
idivl (%rcx)
movl %edx, %ecx
addl %r13d, %ecx
movl %ecx, %eax
cltd
idivl %r12d
testl %edx, %edx
leal 0x5(%rdx,%rdx,4), %eax
cmovel %ecx, %eax
addl %eax, (%rbx)
movl 0x14(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
leaq 0x3db1b(%rip), %rcx     # 0x41254
cmpl (%rcx), %eax
jl 0x37b3
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
addl (%r14), %ebp
addl (%r15), %ebp
movl %ebp, 0x8(%rbx)
leaq 0x3db55(%rip), %rax     # 0x412a8
incl (%rax)
jmp 0x37b3
leaq 0x3dafe(%rip), %r15     # 0x4125c
movl (%r15), %ebp
callq 0x30a0
leaq 0x3daeb(%rip), %rcx     # 0x41258
cltd
idivl (%rcx)
movl %edx, %ecx
addl %ebp, %ecx
pushq $0x5
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
testl %edx, %edx
leal 0x5(%rdx,%rdx,4), %eax
cmovel %ecx, %eax
addl %eax, (%rbx)
movl 0x14(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
leaq 0x3dabd(%rip), %rcx     # 0x41254
cmpl (%rcx), %eax
jl 0x37b3
leaq 0x3db06(%rip), %rax     # 0x412a8
incl (%rax)
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
movl (%r15), %eax
addl (%r14), %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
callq 0x30a0
pushq $0x5
popq %rbp
cltd
idivl %ebp
movl %edx, %r14d
movl 0x14(%rbx), %edi
callq 0x42ed
cmpl $0x1, %eax
jne 0x381d
callq 0x30a0
pushq $0x30
popq %rcx
cltd
idivl %ecx
orl $-0x1, (%rbx)
leaq 0x3daaf(%rip), %rax     # 0x412ac
incl (%rax)
leaq 0x3daa2(%rip), %rax     # 0x412a8
incl (%rax)
leaq 0x3da59(%rip), %rax     # 0x41268
movl (%rax), %eax
addl %edx, %r14d
addl %eax, %r14d
addl $0x5, %r14d
jmp 0x3882
addl $0x4, %r14d
leaq 0x3da38(%rip), %r15     # 0x41260
movl (%r15), %r12d
addl %r14d, %r12d
callq 0x30a0
leaq 0x3da1e(%rip), %rcx     # 0x41258
cltd
idivl (%rcx)
movl %edx, %ecx
addl %r12d, %ecx
movl %ecx, %eax
cltd
idivl %ebp
testl %edx, %edx
leal 0x5(%rdx,%rdx,4), %eax
cmovel %ecx, %eax
addl %eax, (%rbx)
movl 0x14(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
leaq 0x3d9f2(%rip), %rcx     # 0x41254
cmpl (%rcx), %eax
jl 0x3886
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
leaq 0x3da35(%rip), %rax     # 0x412a8
incl (%rax)
leaq 0x3d9ec(%rip), %rax     # 0x41268
addl (%rax), %r14d
addl (%r15), %r14d
movl %r14d, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq 0x3d724(%rip), %rbx     # 0x40fd0
leaq 0x2c751(%rip), %rsi     # 0x30004
movq %rbx, %rdi
callq 0x3260
movq %rax, %rdi
callq 0x3120
leaq 0x2c75e(%rip), %rsi     # 0x30028
movq %rbx, %rdi
callq 0x3260
movq %rax, %rdi
callq 0x3120
leaq 0x2c770(%rip), %rsi     # 0x30051
movq %rbx, %rdi
callq 0x3260
movq %rax, %rdi
callq 0x3120
leaq 0x2c78b(%rip), %rsi     # 0x30083
movq %rbx, %rdi
callq 0x3260
movq %rax, %rdi
popq %rbx
jmp 0x3120
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x3d32d(%rip), %eax     # 0x41264
cmpl $0x2, %eax
je 0x3f9d
cmpl $0x3, %eax
jne 0x3fd0
addq $0x10, %rbx
xorl %r14d, %r14d
movslq 0x3d2f9(%rip), %rax     # 0x4124c
cmpq %rax, %r14
jge 0x3fd0
callq 0x30a0
cvtsi2sd %eax, %xmm0
divsd 0x2c26f(%rip), %xmm0    # 0x301d8
movsd 0x2c26f(%rip), %xmm1    # 0x301e0
movsd 0x2c26f(%rip), %xmm2    # 0x301e8
callq 0x4353
mulsd 0x2c26a(%rip), %xmm0    # 0x301f0
cvttsd2si %xmm0, %eax
leal (%rax,%rax,4), %eax
incl %eax
movl %eax, -0x10(%rbx)
movl %eax, (%rbx)
incq %r14
addq $0x18, %rbx
jmp 0x3f4c
addq $0x10, %rbx
xorl %r14d, %r14d
movl $0x2ee0, %ebp           # imm = 0x2EE0
movslq 0x3d29c(%rip), %rax     # 0x4124c
cmpq %rax, %r14
jge 0x3fd0
callq 0x30a0
cltd
idivl %ebp
leal (%rdx,%rdx,4), %eax
incl %eax
movl %eax, -0x10(%rbx)
movl %eax, (%rbx)
incq %r14
addq $0x18, %rbx
jmp 0x3fa9
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
pushq $0x1
popq %rbx
movslq 0x3d262(%rip), %rax     # 0x41248
cmpq %rax, %r14
jge 0x401b
movq 0x3d2ae(%rip), %rax     # 0x412a0
cmpl $0x2, (%rax,%r14,4)
jl 0x4016
movl %ebx, %edi
callq 0x42ed
testl %eax, %eax
jne 0x4016
movq 0x3d295(%rip), %rax     # 0x412a0
andl $0x0, (%rax,%r14,4)
incl 0x3d286(%rip)           # 0x4129c
incq %r14
jmp 0x3fdf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movq 0x3cf97(%rip), %rdi     # 0x40fd0
leaq 0x2c140(%rip), %rbx     # 0x30180
movq %rbx, %rsi
callq 0x3260
leaq 0x2c312(%rip), %rsi     # 0x30361
movq %rax, %rdi
callq 0x3260
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3260
incl %r15d
movq %rax, %rdi
movl %r15d, %esi
callq 0x33c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3260
leaq 0x2c2e8(%rip), %rsi     # 0x3036a
movq %rax, %rdi
callq 0x3260
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3260
subl %ebp, %r14d
movq %rax, %rdi
movl %r14d, %esi
callq 0x33c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3260
leaq 0x2c2bb(%rip), %rsi     # 0x30370
movq %rax, %rdi
callq 0x3260
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3260
movq %rax, %rdi
movl %ebp, %esi
callq 0x33c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3260
leaq 0x2c294(%rip), %rsi     # 0x30378
movq %rax, %rdi
callq 0x3260
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3260
movl 0x3d19f(%rip), %esi     # 0x4129c
movq %rax, %rdi
callq 0x33c0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3120
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/main.cpp
// Function: analysisForNode(End&, int)
void analysisForNode(End &e, int i) {
	string _state;
	 if (e.getStartTime() == -1)
		_state = "o";
	else if (e.getStartTime() == -2)
		_state = "xxx";
	else _state = "==err==";
	
	cout << "\t" << "node" << "\t" << (i+1)
	<< "\t" << "start" << "\t" << e.getStart()
	<< "\t" << "delay" << "\t" << e.getDelayTime()
	<< "\t" << "retrans" << "\t" << e.getIndex()
	<< "\t" << "collision" << "\t" << e.getCollision()
	<< "\t" << "finally" << "\t" << _state
	<< endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
movl (%rdi), %eax
cmpl $-0x2, %eax
leaq 0x2c243(%rip), %rcx     # 0x30384
leaq 0x2c240(%rip), %rdx     # 0x30388
cmoveq %rcx, %rdx
cmpl $-0x1, %eax
leaq 0x2c22c(%rip), %rsi     # 0x30382
cmovneq %rdx, %rsi
movq %rsp, %rdi
callq 0x3440
movq 0x3ce67(%rip), %rdi     # 0x40fd0
leaq 0x2c010(%rip), %rsi     # 0x30180
callq 0x3260
leaq 0x2c214(%rip), %rsi     # 0x30390
movq %rax, %rdi
callq 0x3260
leaq 0x2bff5(%rip), %rsi     # 0x30180
movq %rax, %rdi
callq 0x3260
incl %ebp
movq %rax, %rdi
movl %ebp, %esi
callq 0x33c0
leaq 0x2bfda(%rip), %rsi     # 0x30180
movq %rax, %rdi
callq 0x3260
leaq 0x2c1e0(%rip), %rsi     # 0x30395
movq %rax, %rdi
callq 0x3260
leaq 0x2bfbc(%rip), %rsi     # 0x30180
movq %rax, %rdi
callq 0x3260
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x33c0
leaq 0x2bfa2(%rip), %rsi     # 0x30180
movq %rax, %rdi
callq 0x3260
leaq 0x2c1ae(%rip), %rsi     # 0x3039b
movq %rax, %rdi
callq 0x3260
leaq 0x2bf84(%rip), %rsi     # 0x30180
movq %rax, %rdi
callq 0x3260
movq %rax, %r14
movq %rbx, %rdi
callq 0x43d6
movq %r14, %rdi
movl %eax, %esi
callq 0x33c0
leaq 0x2bf60(%rip), %rsi     # 0x30180
movq %rax, %rdi
callq 0x3260
leaq 0x2c172(%rip), %rsi     # 0x303a1
movq %rax, %rdi
callq 0x3260
leaq 0x2bf42(%rip), %rsi     # 0x30180
movq %rax, %rdi
callq 0x3260
movl 0x14(%rbx), %esi
movq %rax, %rdi
callq 0x33c0
leaq 0x2bf28(%rip), %rsi     # 0x30180
movq %rax, %rdi
callq 0x3260
leaq 0x2c111(%rip), %rsi     # 0x30378
movq %rax, %rdi
callq 0x3260
leaq 0x2bf0a(%rip), %rsi     # 0x30180
movq %rax, %rdi
callq 0x3260
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x33c0
leaq 0x2bef0(%rip), %rsi     # 0x30180
movq %rax, %rdi
callq 0x3260
leaq 0x2c10a(%rip), %rsi     # 0x303a9
movq %rax, %rdi
callq 0x3260
leaq 0x2bed2(%rip), %rsi     # 0x30180
movq %rax, %rdi
callq 0x3260
movq %rsp, %rsi
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
callq 0x3120
movq %rsp, %rdi
callq 0x3100
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x18, %rsp
cvtsi2sd %edi, %xmm0
xorpd 0x2beb3(%rip), %xmm0    # 0x301b0
callq 0x3400
movsd 0x2beee(%rip), %xmm1    # 0x301f8
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
subsd %xmm2, %xmm1
unpcklpd %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0]
mulpd 0x2be9e(%rip), %xmm1    # 0x301c0
cvttpd2dq %xmm1, %xmm0
movapd %xmm0, (%rsp)
callq 0x30a0
movdqa (%rsp), %xmm0
movd %xmm0, %ecx
pshufd $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movd %xmm0, %esi
addl %esi, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl %esi, %edx
setle %al
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x44b6
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x4482
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3c70f(%rip), %rsi     # 0x40b80
leaq 0xe2a0(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x4487
callq 0x3330
movq %rax, %rbx
jmp 0x4497
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x44a6
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x48dc
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x48a8
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3c2e9(%rip), %rsi     # 0x40b80
leaq 0xde7a(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x48ad
callq 0x3330
movq %rax, %rbx
jmp 0x48bd
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x48cc
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x4daf
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x4d7b
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3be16(%rip), %rsi     # 0x40b80
leaq 0xd9a7(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x4d80
callq 0x3330
movq %rax, %rbx
jmp 0x4d90
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x4d9f
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x24437
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x2440c
movsd 0x2b6a7(%rip), %xmm1    # 0x30488
movsd %xmm0, (%rsp)
callq 0x24239
testb %al, %al
je 0x4ebc
movsd (%rsp), %xmm4
movapd %xmm4, %xmm1
mulsd %xmm4, %xmm1
movsd 0x2b770(%rip), %xmm0    # 0x30578
mulsd %xmm1, %xmm0
addsd 0x2b76c(%rip), %xmm0    # 0x30580
mulsd %xmm1, %xmm0
addsd 0x2b768(%rip), %xmm0    # 0x30588
mulsd %xmm1, %xmm0
addsd 0x2b764(%rip), %xmm0    # 0x30590
mulsd %xmm1, %xmm0
addsd 0x2b760(%rip), %xmm0    # 0x30598
mulsd %xmm1, %xmm0
addsd 0x2b75c(%rip), %xmm0    # 0x305a0
xorpd %xmm2, %xmm2
mulsd %xmm1, %xmm2
addsd 0x2b3a4(%rip), %xmm2    # 0x301f8
mulsd %xmm1, %xmm2
addsd 0x2b750(%rip), %xmm2    # 0x305b0
mulsd %xmm1, %xmm2
addsd 0x2b74c(%rip), %xmm2    # 0x305b8
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm2
addsd 0x2b744(%rip), %xmm2    # 0x305c0
movsd 0x2b724(%rip), %xmm3    # 0x305a8
mulsd %xmm1, %xmm2
addsd 0x2b738(%rip), %xmm2    # 0x305c8
addsd %xmm3, %xmm0
mulsd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x2b72a(%rip), %xmm1    # 0x305d0
addsd %xmm3, %xmm2
mulsd %xmm4, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm2, %xmm1
movapd %xmm1, %xmm0
jmp 0x4efd
movsd 0x2b6ac(%rip), %xmm1    # 0x30570
movsd (%rsp), %xmm0
callq 0x24295
testb %al, %al
je 0x4eda
movsd 0x8(%rsp), %xmm0
jmp 0x4efd
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x4fb9
movsd 0x2b309(%rip), %xmm1    # 0x301f8
subsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x4fb9
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x4f85
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3bc0c(%rip), %rsi     # 0x40b80
leaq 0xd79d(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x4f8a
callq 0x3330
movq %rax, %rbx
jmp 0x4f9a
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x4fa9
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x51fe
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x51ca
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3b9c7(%rip), %rsi     # 0x40b80
leaq 0xd558(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x51cf
callq 0x3330
movq %rax, %rbx
jmp 0x51df
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x51ee
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x58, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x52d4
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x52a0
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3b8f1(%rip), %rsi     # 0x40b80
leaq 0xd482(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x52a5
callq 0x3330
movq %rax, %rbx
jmp 0x52b5
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x52c4
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x53d1
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x539d
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3b7f4(%rip), %rsi     # 0x40b80
leaq 0xd385(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x53a2
callq 0x3330
movq %rax, %rbx
jmp 0x53b2
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x53c1
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23772
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0x579e
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x576a
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3b427(%rip), %rsi     # 0x40b80
leaq 0xcfb8(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x576f
callq 0x3330
movq %rax, %rbx
jmp 0x577f
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x578e
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::incompletegamma(double, double, alglib_impl::ae_state*)
double incompletegamma(double a, double x, ae_state *_state)
{
    double igammaepsilon;
    double ans;
    double ax;
    double c;
    double r;
    double tmp;
    double result;


    igammaepsilon = 0.000000000000001;
    if( ae_fp_less_eq(x,0)||ae_fp_less_eq(a,0) )
    {
        result = 0;
        return result;
    }
    if( ae_fp_greater(x,1)&&ae_fp_greater(x,a) )
    {
        result = 1-incompletegammac(a, x, _state);
        return result;
    }
    ax = a*ae_log(x, _state)-x-lngamma(a, &tmp, _state);
    if( ae_fp_less(ax,-709.78271289338399) )
    {
        result = 0;
        return result;
    }
    ax = ae_exp(ax, _state);
    r = a;
    c = 1;
    ans = 1;
    do
    {
        r = r+1;
        c = c*x/r;
        ans = ans+c;
    }
    while(ae_fp_greater(c/ans,igammaepsilon));
    result = ans*ax/a;
    return result;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movapd %xmm1, %xmm2
movsd %xmm0, 0x8(%rsp)
xorpd %xmm1, %xmm1
movsd %xmm2, 0x10(%rsp)
movapd %xmm2, %xmm0
callq 0x24259
xorpd %xmm2, %xmm2
testb %al, %al
jne 0x592f
xorpd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x24259
testb %al, %al
je 0x57eb
xorpd %xmm2, %xmm2
jmp 0x592f
movsd 0x2aa05(%rip), %xmm1    # 0x301f8
movsd 0x10(%rsp), %xmm0
callq 0x24279
testb %al, %al
je 0x583c
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x24279
testb %al, %al
je 0x583c
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %rbx, %rdi
callq 0x59ff
movsd 0x2a9c5(%rip), %xmm2    # 0x301f8
subsd %xmm0, %xmm2
jmp 0x592f
movsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x2455f
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm1
subsd 0x10(%rsp), %xmm1
movsd %xmm1, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x48dc
movsd 0x18(%rsp), %xmm2
subsd %xmm0, %xmm2
movsd 0x2ae9d(%rip), %xmm1    # 0x30720
movsd %xmm2, 0x18(%rsp)
movapd %xmm2, %xmm0
callq 0x24239
testb %al, %al
xorpd %xmm2, %xmm2
jne 0x592f
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
callq 0x24569
movsd %xmm0, 0x20(%rsp)
movsd 0x2a93e(%rip), %xmm0    # 0x301f8
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm3
addsd %xmm0, %xmm3
movsd %xmm3, 0x28(%rsp)
mulsd 0x10(%rsp), %xmm2
divsd %xmm3, %xmm2
movsd %xmm2, 0x30(%rsp)
addsd %xmm2, %xmm1
movsd %xmm1, 0x18(%rsp)
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
movsd 0x2ae2c(%rip), %xmm1    # 0x30728
callq 0x24279
movsd 0x28(%rsp), %xmm3
movsd 0x30(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
movsd 0x2a8dd(%rip), %xmm0    # 0x301f8
testb %al, %al
jne 0x58c8
movsd 0x20(%rsp), %xmm2
mulsd %xmm1, %xmm2
divsd 0x8(%rsp), %xmm2
movapd %xmm2, %xmm0
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0x59ff
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x59cb
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3b1c6(%rip), %rsi     # 0x40b80
leaq 0xcd57(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x59d0
callq 0x3330
movq %rax, %rbx
jmp 0x59e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x59ef
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0x5d6b
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x23631
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x5d37
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3ae5a(%rip), %rsi     # 0x40b80
leaq 0xc9eb(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x5d3c
callq 0x3330
movq %rax, %rbx
jmp 0x5d4c
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x5d5b
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x23772
movsd 0x8(%rsp), %xmm0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x6323
leaq 0x10(%rsp), %rdi
callq 0x23631
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x62ef
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x3a8a2(%rip), %rsi     # 0x40b80
leaq 0xc433(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x62f4
callq 0x3330
movq %rax, %rbx
jmp 0x6304
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x6313
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x7181
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x714d
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x39a44(%rip), %rsi     # 0x40b80
leaq 0xb5d5(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x7152
callq 0x3330
movq %rax, %rbx
jmp 0x7162
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x7171
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besseljn(long, double)
double besseljn(const ae_int_t n, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besseljn(n, 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)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x23772
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x7464
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x7430
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x39761(%rip), %rsi     # 0x40b80
leaq 0xb2f2(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x7435
callq 0x3330
movq %rax, %rbx
jmp 0x7445
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x7454
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::bessely0(double)
double bessely0(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::bessely0(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 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x7744
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x7710
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x39481(%rip), %rsi     # 0x40b80
leaq 0xb012(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x7715
callq 0x3330
movq %rax, %rbx
jmp 0x7725
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x7734
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besselyn(long, double)
double besselyn(const ae_int_t n, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besselyn(n, 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)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x23772
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x7c6e
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x7c3a
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x38f57(%rip), %rsi     # 0x40b80
leaq 0xaae8(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x7c3f
callq 0x3330
movq %rax, %rbx
jmp 0x7c4f
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x7c5e
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib_impl::besselyn(long, double, alglib_impl::ae_state*)
double besselyn(ae_int_t n, double x, ae_state *_state)
{
    ae_int_t i;
    double a;
    double b;
    double tmp;
    double s;
    double result;


    s = 1;
    if( n<0 )
    {
        n = -n;
        if( n%2!=0 )
        {
            s = -1;
        }
    }
    if( n==0 )
    {
        result = bessely0(x, _state);
        return result;
    }
    if( n==1 )
    {
        result = s*bessely1(x, _state);
        return result;
    }
    a = bessely0(x, _state);
    b = bessely1(x, _state);
    for(i=1; i<=n-1; i++)
    {
        tmp = b;
        b = 2*i/x*b-a;
        a = tmp;
    }
    result = s*b;
    return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x28575(%rip), %xmm1    # 0x301f8
testq %rdi, %rdi
jns 0x7c98
negq %rbx
testb $0x1, %bl
je 0x7c98
movsd 0x28568(%rip), %xmm1    # 0x30200
cmpq $0x1, %rbx
je 0x7cb2
testq %rbx, %rbx
jne 0x7cd4
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x7744
movsd %xmm1, (%rsp)
movq %r14, %rdi
callq 0x799f
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
jmp 0x7d41
movsd %xmm1, (%rsp)
movq %r14, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x7744
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
callq 0x799f
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
pushq $0x1
popq %rax
pushq $0x2
popq %rcx
cmpq %rbx, %rax
jge 0x7d34
cvtsi2sd %rcx, %xmm1
divsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
subsd %xmm3, %xmm1
incq %rax
addq $0x2, %rcx
movapd %xmm0, %xmm3
movapd %xmm1, %xmm0
jmp 0x7d0d
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besseli0(double)
double besseli0(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besseli0(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 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x7dff
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x7dcb
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x38dc6(%rip), %rsi     # 0x40b80
leaq 0xa957(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x7dd0
callq 0x3330
movq %rax, %rbx
jmp 0x7de0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x7def
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d
// File: /workspace/github_cpp_makefile_star2_O2/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besseli1(double)
double besseli1(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besseli1(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 0x23772
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x83cc
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x23631
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %ebx
jne 0x8398
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x26d2a
leaq 0x387f9(%rip), %rsi     # 0x40b80
leaq 0xa38a(%rip), %rdx      # 0x12718
movq %r14, %rdi
callq 0x33b0
jmp 0x839d
callq 0x3330
movq %rax, %rbx
jmp 0x83ad
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
callq 0x3380
jmp 0x83bc
movq %rax, %rbx
callq 0x3380
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x1270d