LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6c061
leaq 0x2163d(%rip), %rsi     # 0x8d648
leaq 0x2205e(%rip), %rdx     # 0x8e070
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
je 0x6c03c
movq 0x28(%rax), %rbx
movq 0x30(%rax), %r14
cmpq %r14, %rbx
je 0x6c059
movq (%rbx), %rsi
callq 0x6c0b2
addq $0x8, %rbx
jmp 0x6c029
leaq 0x21605(%rip), %rsi     # 0x8d648
leaq 0x228b6(%rip), %rdx     # 0x8e900
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8320
testq %rax, %rax
je 0x6c061
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x22f80(%rip), %rdi     # 0x8efe8
leaq 0x20f9(%rip), %rsi      # 0x6e168
callq 0x8280
leaq 0x5c03(%rip), %rsi      # 0x71c7e
movq %rax, %rdi
callq 0x8280
leaq 0x3336(%rip), %rsi      # 0x6f3c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x16, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
nop
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/End.cpp
// Function: End::settime()
void End::settime()
{
    if (_setTime != _time)
	return;
    if(preamble[_preamble] == 1) {
	id();// case for success
    }
    else if (preamble[_preamble] > 1){
	int Fwait = rand() % 5 + 1;
	_collision++;
	_setTime += _CountCeil(/*lte::firstWaiting*/ (Fwait + 3) + lte::secondWaiting + rand()%lte::RandomBackoffIndex);
	_index++;
	if(_index > lte::MAX) {
	    _setTime = -2;
	    _finish = _time + (Fwait + 3) + lte::secondWaiting;
	    _count++;
	}
    }else {
	_setTime += _CountCeil(lte::firstWaiting + rand()%lte::RandomBackoffIndex);
	//set the next preamble transmission time
	_index++;
	if(_index > lte::MAX){
	    _count++;
	    _setTime = -2;
	    _finish = _time + lte::firstWaiting;
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rdi), %eax
leaq 0x3fb83(%rip), %r14     # 0x43278
cmpl (%r14), %eax
jne 0x383c
movq %rdi, %rbx
leaq 0x3fba8(%rip), %rax     # 0x432b0
movq (%rax), %rax
movslq 0x4(%rdi), %rcx
movl (%rax,%rcx,4), %eax
cmpl $0x1, %eax
jne 0x3727
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3846
jle 0x37ce
callq 0x30b0
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
incl 0xc(%rbx)
negl %ecx
leal (%rax,%rcx), %ebp
addl $0x4, %ebp
leaq 0x3fb13(%rip), %r15     # 0x43270
movl (%r15), %r12d
addl %ebp, %r12d
callq 0x30b0
leaq 0x3faf9(%rip), %rcx     # 0x43268
cltd
idivl (%rcx)
addl %r12d, %edx
movslq %edx, %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
movl %eax, %edx
subl %ecx, %edx
leal 0x5(%rdx,%rdx,4), %ecx
cmovel %eax, %ecx
addl %ecx, (%rbx)
movl 0x14(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
leaq 0x3fab8(%rip), %rcx     # 0x43264
cmpl (%rcx), %eax
jl 0x383c
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
addl (%r14), %ebp
addl (%r15), %ebp
movl %ebp, 0x8(%rbx)
leaq 0x3faee(%rip), %rax     # 0x432b8
incl (%rax)
jmp 0x383c
leaq 0x3fa97(%rip), %r15     # 0x4326c
movl (%r15), %ebp
callq 0x30b0
leaq 0x3fa84(%rip), %rcx     # 0x43268
cltd
idivl (%rcx)
addl %ebp, %edx
movslq %edx, %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
movl %eax, %edx
subl %ecx, %edx
leal 0x5(%rdx,%rdx,4), %ecx
cmovel %eax, %ecx
addl %ecx, (%rbx)
movl 0x14(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
leaq 0x3fa44(%rip), %rcx     # 0x43264
cmpl (%rcx), %eax
jl 0x383c
leaq 0x3fa8d(%rip), %rax     # 0x432b8
incl (%rax)
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
movl (%r15), %eax
addl (%r14), %eax
movl %eax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/End.cpp
// Function: End::id()
void End::id()
{
  int Fwait = rand() % 5 + 1;
  if ( setProbablity(_index) == 1 ) {
    int Swait = rand() % 48 + 1;
    _setTime = -1;
    _goodEnd++;
    _count++;
    _finish = _time + (3 +Fwait) + Swait;
  } else {
	_setTime += _CountCeil(/*lte::firstWaiting*/ (Fwait + 3) + lte::secondWaiting + rand()%lte::RandomBackoffIndex);
	_index++;
	if ( _index > lte::MAX ) {
	    _setTime = -2;
	    _count++;
	    _finish = _time + (3 + Fwait) + lte::secondWaiting;
	}
  }
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x3ef6a(%rip), %eax     # 0x43274
cmpl $0x2, %eax
je 0x43c5
cmpl $0x3, %eax
jne 0x4415
cmpl $0x0, 0x3ef39(%rip)     # 0x4325c
jle 0x4415
addq $0x10, %rbx
xorl %r14d, %r14d
callq 0x30b0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd 0x2ee94(%rip), %xmm1    # 0x331d8
movsd 0x2ee94(%rip), %xmm0    # 0x331e0
subsd %xmm1, %xmm0
mulsd %xmm1, %xmm1
movsd %xmm1, (%rsp)
movsd 0x2ee87(%rip), %xmm1    # 0x331e8
callq 0x3410
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x2ee70(%rip), %xmm0    # 0x331e8
movsd 0x2ee70(%rip), %xmm1    # 0x331f0
callq 0xa093
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
divsd 0x2ee62(%rip), %xmm1    # 0x331f8
mulsd 0x2ee62(%rip), %xmm1    # 0x33200
cvttsd2si %xmm1, %eax
leal (%rax,%rax,4), %eax
incl %eax
movl %eax, -0x10(%rbx)
movl %eax, (%rbx)
incq %r14
movslq 0x3eea6(%rip), %rax     # 0x4325c
addq $0x18, %rbx
cmpq %rax, %r14
jl 0x4330
jmp 0x4415
cmpl $0x0, 0x3ee90(%rip)     # 0x4325c
jle 0x4415
addq $0x10, %rbx
xorl %r14d, %r14d
callq 0x30b0
cltq
imulq $0x57619f1, %rax, %rcx  # imm = 0x57619F1
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x28, %rcx
addl %edx, %ecx
imull $0x2ee0, %ecx, %ecx     # imm = 0x2EE0
subl %ecx, %eax
leal (%rax,%rax,4), %eax
incl %eax
movl %eax, -0x10(%rbx)
movl %eax, (%rbx)
incq %r14
movslq 0x3ee50(%rip), %rax     # 0x4325c
addq $0x18, %rbx
cmpq %rax, %r14
jl 0x43d5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/main.cpp
// Function: responseForUseSamePreamble()
void responseForUseSamePreamble()
{
    for( int i = 0; i < lte::preambleNum;  i++ ){
	if( preamble[i] > 1 ){
	//preamble[i] = setProbablity(1); 
	    if (setProbablity(1) == 0) { 
		preamble[i] = 0;
		collision_time++;
	    }
	}
  }
}

// Assembly:
cmpl $0x0, 0x3ee34(%rip)     # 0x43258
jle 0x4468
pushq %rbx
movq 0x3ee82(%rip), %rcx     # 0x432b0
xorl %ebx, %ebx
cmpl $0x2, (%rcx,%rbx,4)
jl 0x4458
movl $0x1, %edi
callq 0x4896
movq 0x3ee69(%rip), %rcx     # 0x432b0
testl %eax, %eax
jne 0x4458
movl $0x0, (%rcx,%rbx,4)
incl 0x3ee54(%rip)           # 0x432ac
incq %rbx
movslq 0x3edf6(%rip), %rax     # 0x43258
cmpq %rax, %rbx
jl 0x4430
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/main.cpp
// Function: analysisForEvent(int, int, int)
void analysisForEvent(int _time, int _count, int _goodEnd) {
	cout << "\t" << "time(ms)" << "\t" << (_time+1)
	<< "\t" << "abort" << "\t" << (_count-_goodEnd)
	<< "\t" << "success" << "\t" << (_goodEnd)
	<< "\t" << "collision" << "\t" << collision_time
	<< endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movq 0x3eb50(%rip), %r12     # 0x42fd0
leaq 0x2ecf9(%rip), %rbx     # 0x33180
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x32d0
leaq 0x2eec3(%rip), %rsi     # 0x33361
movl $0x8, %edx
movq %r12, %rdi
callq 0x32d0
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x32d0
incl %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x3400
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32d0
leaq 0x2ee87(%rip), %rsi     # 0x3336a
movl $0x5, %edx
movq %r15, %rdi
callq 0x32d0
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x32d0
subl %ebp, %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x3400
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32d0
leaq 0x2ee48(%rip), %rsi     # 0x33370
movl $0x7, %edx
movq %r14, %rdi
callq 0x32d0
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32d0
movq %r14, %rdi
movl %ebp, %esi
callq 0x3400
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32d0
leaq 0x2ee0f(%rip), %rsi     # 0x33378
movl $0x9, %edx
movq %r14, %rdi
callq 0x32d0
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32d0
movl 0x3ed20(%rip), %esi     # 0x432ac
movq %r14, %rdi
callq 0x3400
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e90a(%rip), %xmm0    # 0x331b0
callq 0x3440
movsd 0x2e92d(%rip), %xmm1    # 0x331e0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
subsd %xmm2, %xmm1
unpcklpd %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0]
mulpd 0x2e8f5(%rip), %xmm1    # 0x331c0
cvttpd2dq %xmm1, %xmm0
movapd %xmm0, (%rsp)
callq 0x30b0
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_O3/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 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x4a38
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x4a04
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3e18d(%rip), %rsi     # 0x42b80
leaq 0xe8c8(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x4a09
callq 0x3360
movq %rax, %rbx
jmp 0x4a19
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x4a28
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e80
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x4e4c
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3dd45(%rip), %rsi     # 0x42b80
leaq 0xe480(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x4e51
callq 0x3360
movq %rax, %rbx
jmp 0x4e61
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x4e70
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x53c7
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x5393
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3d7fe(%rip), %rsi     # 0x42b80
leaq 0xdf39(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x5398
callq 0x3360
movq %rax, %rbx
jmp 0x53a8
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x53b7
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25e5b
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x25e30
movsd 0x2e08c(%rip), %xmm1    # 0x33488
movsd %xmm0, (%rsp)
callq 0x25bb9
testb %al, %al
je 0x54d7
movsd (%rsp), %xmm4
movapd %xmm4, %xmm1
mulsd %xmm4, %xmm1
movsd 0x2e155(%rip), %xmm0    # 0x33578
mulsd %xmm1, %xmm0
addsd 0x2e151(%rip), %xmm0    # 0x33580
mulsd %xmm1, %xmm0
addsd 0x2e14d(%rip), %xmm0    # 0x33588
mulsd %xmm1, %xmm0
addsd 0x2e149(%rip), %xmm0    # 0x33590
mulsd %xmm1, %xmm0
addsd 0x2e145(%rip), %xmm0    # 0x33598
mulsd %xmm1, %xmm0
addsd 0x2e141(%rip), %xmm0    # 0x335a0
xorpd %xmm2, %xmm2
mulsd %xmm1, %xmm2
addsd 0x2dd71(%rip), %xmm2    # 0x331e0
mulsd %xmm1, %xmm2
addsd 0x2e135(%rip), %xmm2    # 0x335b0
mulsd %xmm1, %xmm2
addsd 0x2e131(%rip), %xmm2    # 0x335b8
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm2
addsd 0x2e129(%rip), %xmm2    # 0x335c0
movsd 0x2e109(%rip), %xmm3    # 0x335a8
mulsd %xmm1, %xmm2
addsd 0x2e11d(%rip), %xmm2    # 0x335c8
addsd %xmm3, %xmm0
mulsd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x2e10f(%rip), %xmm1    # 0x335d0
addsd %xmm3, %xmm2
mulsd %xmm4, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm2, %xmm1
movapd %xmm1, %xmm0
jmp 0x5518
movsd 0x2e091(%rip), %xmm1    # 0x33570
movsd (%rsp), %xmm0
callq 0x25c15
testb %al, %al
je 0x54f5
movsd 0x8(%rsp), %xmm0
jmp 0x5518
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x55d6
movsd 0x2dcd6(%rip), %xmm1    # 0x331e0
subsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x55d6
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x55a2
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3d5ef(%rip), %rsi     # 0x42b80
leaq 0xdd2a(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x55a7
callq 0x3360
movq %rax, %rbx
jmp 0x55b7
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x55c6
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm0
divsd 0x2dec5(%rip), %xmm0    # 0x33650
movq %rbx, %rdi
callq 0x53c7
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addsd 0x2da31(%rip), %xmm0    # 0x331e0
mulsd 0x2dcd1(%rip), %xmm0    # 0x33488
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x5801
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3d390(%rip), %rsi     # 0x42b80
leaq 0xdacb(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x5806
callq 0x3360
movq %rax, %rbx
jmp 0x5816
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x5825
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::inverf(double)
double inverf(const double e)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::inverf(e, &_alglib_env_state);
        alglib_impl::ae_state_clear(&_alglib_env_state);
        return *(reinterpret_cast<double*>(&result));
    }
    catch(alglib_impl::ae_error_type)
    {
        throw ap_error(_alglib_env_state.error_msg);
    }
    catch(...)
    {
        throw;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x24fa7
movsd 0x8(%rsp), %xmm0
addsd 0x2d963(%rip), %xmm0    # 0x331e0
mulsd 0x2dc03(%rip), %xmm0    # 0x33488
movq %rbx, %rdi
callq 0x5a3e
movsd %xmm0, 0x8(%rsp)
movsd 0x2db65(%rip), %xmm0    # 0x33400
leaq 0x18(%rsp), %rdi
callq 0x25e48
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x24e4e
movsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x590b
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3d286(%rip), %rsi     # 0x42b80
leaq 0xd9c1(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x5910
callq 0x3360
movq %rax, %rbx
jmp 0x5920
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x592f
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x5a3e
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x5a0a
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3d187(%rip), %rsi     # 0x42b80
leaq 0xd8c2(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x5a0f
callq 0x3360
movq %rax, %rbx
jmp 0x5a1f
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x5a2e
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0x5e0d
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x24e4e
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x5dd9
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3cdb8(%rip), %rsi     # 0x42b80
leaq 0xd4f3(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x5dde
callq 0x3360
movq %rax, %rbx
jmp 0x5dee
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x5dfd
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25bd9
xorpd %xmm2, %xmm2
testb %al, %al
jne 0x5f9e
xorpd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x25bd9
testb %al, %al
je 0x5e5a
xorpd %xmm2, %xmm2
jmp 0x5f9e
movsd 0x2d37e(%rip), %xmm1    # 0x331e0
movsd 0x10(%rsp), %xmm0
callq 0x25bf9
testb %al, %al
je 0x5eab
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x25bf9
testb %al, %al
je 0x5eab
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %rbx, %rdi
callq 0x6070
movsd 0x2d33e(%rip), %xmm2    # 0x331e0
subsd %xmm0, %xmm2
jmp 0x5f9e
movsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25f91
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 0x4e80
movsd 0x18(%rsp), %xmm2
subsd %xmm0, %xmm2
movsd 0x2d82e(%rip), %xmm1    # 0x33720
movsd %xmm2, 0x18(%rsp)
movapd %xmm2, %xmm0
callq 0x25bb9
testb %al, %al
xorpd %xmm2, %xmm2
jne 0x5f9e
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
callq 0x25f9b
movsd %xmm0, 0x20(%rsp)
movsd 0x2d2b7(%rip), %xmm0    # 0x331e0
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 0x2d7bd(%rip), %xmm1    # 0x33728
callq 0x25bf9
movsd 0x28(%rsp), %xmm3
movsd 0x30(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
movsd 0x2d256(%rip), %xmm0    # 0x331e0
testb %al, %al
jne 0x5f37
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_O3/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 0x24fa7
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0x6070
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x24e4e
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x603c
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3cb55(%rip), %rsi     # 0x42b80
leaq 0xd290(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x6041
callq 0x3360
movq %rax, %rbx
jmp 0x6051
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x6060
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
callq 0x63de
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x24e4e
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x63aa
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x60(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3c7e7(%rip), %rsi     # 0x42b80
leaq 0xcf22(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x63af
callq 0x3360
movq %rax, %rbx
jmp 0x63bf
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x63ce
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd 0x8(%rsp), %xmm0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x69dd
leaq 0x10(%rsp), %rdi
callq 0x24e4e
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x69a9
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3c1e8(%rip), %rsi     # 0x42b80
leaq 0xc923(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x69ae
callq 0x3360
movq %rax, %rbx
jmp 0x69be
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x69cd
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x7894
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x7860
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3b331(%rip), %rsi     # 0x42b80
leaq 0xba6c(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x7865
callq 0x3360
movq %rax, %rbx
jmp 0x7875
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x7884
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x7b7c
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x7b48
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3b049(%rip), %rsi     # 0x42b80
leaq 0xb784(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x7b4d
callq 0x3360
movq %rax, %rbx
jmp 0x7b5d
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x7b6c
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x7e76
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x7e42
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3ad4f(%rip), %rsi     # 0x42b80
leaq 0xb48a(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x7e47
callq 0x3360
movq %rax, %rbx
jmp 0x7e57
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x7e66
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x83a4
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x8370
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3a821(%rip), %rsi     # 0x42b80
leaq 0xaf5c(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x8375
callq 0x3360
movq %rax, %rbx
jmp 0x8385
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x8394
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ae27(%rip), %xmm1    # 0x331e0
testq %rdi, %rdi
jns 0x83ce
negq %rbx
testb $0x1, %bl
je 0x83ce
movsd 0x2ae3a(%rip), %xmm1    # 0x33208
cmpq $0x1, %rbx
je 0x83e8
testq %rbx, %rbx
jne 0x840a
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x7e76
movsd %xmm1, (%rsp)
movq %r14, %rdi
callq 0x80d3
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
jmp 0x8477
movsd %xmm1, (%rsp)
movq %r14, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x7e76
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movq %r14, %rdi
callq 0x80d3
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
decq %rbx
movl $0x2, %eax
movapd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
subsd %xmm3, %xmm0
addq $0x2, %rax
movapd %xmm1, %xmm3
decq %rbx
jne 0x8445
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x8537
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x8503
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3a68e(%rip), %rsi     # 0x42b80
leaq 0xadc9(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x8508
callq 0x3360
movq %rax, %rbx
jmp 0x8518
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x8527
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x8b06
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x8ad2
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3a0bf(%rip), %rsi     # 0x42b80
leaq 0xa7fa(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x8ad7
callq 0x3360
movq %rax, %rbx
jmp 0x8ae7
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x8af6
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besselk1(double)
double besselk1(const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besselk1(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 0x24fa7
movsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x9527
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x94f3
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x3969e(%rip), %rsi     # 0x42b80
leaq 0x9dd9(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x94f8
callq 0x3360
movq %rax, %rbx
jmp 0x9508
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x9517
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7
// File: /workspace/github_cpp_makefile_star2_O3/mouda[P]LTE_random_access-simulate/specialfunctions.cpp
// Function: alglib::besselkn(long, double)
double besselkn(const ae_int_t nn, const double x)
{
    alglib_impl::ae_state _alglib_env_state;
    alglib_impl::ae_state_init(&_alglib_env_state);
    try
    {
        double result = alglib_impl::besselkn(nn, 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 0x24fa7
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rsi
callq 0x99c1
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x24e4e
movsd (%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rax, %rdi
callq 0x3100
cmpl $0x2, %ebx
jne 0x998d
movl $0x20, %edi
callq 0x3140
movq %rax, %r14
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x28d64
leaq 0x39204(%rip), %rsi     # 0x42b80
leaq 0x993f(%rip), %rdx      # 0x132c2
movq %r14, %rdi
callq 0x33f0
jmp 0x9992
callq 0x3360
movq %rax, %rbx
jmp 0x99a2
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
callq 0x33c0
jmp 0x99b1
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x132b7