LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/Heating.c
// Function: RhoTempFieldWithHeating(double, double*, double*, double*, long)
void RhoTempFieldWithHeating(double HeatTemp, double* TField, double* RhoField, double* Rho_T_Field, long N)
// Calculates the rho*T field where heating is taken into account
{
	long i;
	double factor=1.0;
	double HeatTemp4=pow(HeatTemp,4.0);
	#if (R05Heating==true)
	double x,y,z;
	const long Nsq=Ngrid*Ngrid;
	const double Nhalf=(double)(Ngrid-1)/2.0;
	#endif
	
	for(i=0;i<N;i++){
		#if (R05Heating==true)
		x= (double)(i/Nsq)-Nhalf; //x coordinate index
     	y= (double)((i % Nsq)/Ngrid)-Nhalf; //y coordinate index
     	z= (double)(i % Ngrid)-Nhalf; //z coordinate index
     	factor=Nhalf*Nhalf/(x*x+y*y+z*z); // (sqrt(r0/r))^4
     	#endif
		Rho_T_Field[i]=pow(factor*HeatTemp4+pow(TField[i],4.0),0.25)*RhoField[i];
	}
}

// Assembly:
subq $0x58, %rsp
movsd %xmm0, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movsd 0xb5e2(%rip), %xmm0     # 0x1c158
movsd %xmm0, 0x20(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0xb8ae(%rip), %xmm1     # 0x1c438
callq 0x8bc0
movsd %xmm0, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rax
jge 0x10c37
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq 0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0xb85b(%rip), %xmm1     # 0x1c438
callq 0x8bc0
movsd 0x8(%rsp), %xmm2
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xb83f(%rip), %xmm1     # 0x1c440
callq 0x8bc0
movq 0x40(%rsp), %rax
movq 0x28(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x10b9e
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/EvolveField.c
// Function: SetOptimaldt(double, double, double)
double SetOptimaldt(double dt,double renormstepMax,double dDeltaKMax){
	double newdt; // new value for dt/t0 to use
	double newrenormstepMax; //the value of renormstepMax after changing to newdt
	
	// First optimize for density variance steps (this is quadratic)
    newdt=dt*(dDeltaKOptimal/dDeltaKMax)*(dDeltaKOptimal/dDeltaKMax);
    newrenormstepMax=renormstepMax*newdt/dt; //linear relation
    // Check if this is acceptable for the dt/tau steps
	if (newrenormstepMax>RenormstepOptimal){
    	newdt=newdt*(RenormstepOptimal/newrenormstepMax); //linear dependence
	}
	
return newdt;	
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movsd %xmm1, -0x10(%rsp)
movsd %xmm2, -0x18(%rsp)
movsd -0x8(%rsp), %xmm0
movsd 0x5df8(%rip), %xmm1     # 0x1c178
divsd -0x18(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x5de6(%rip), %xmm1     # 0x1c178
divsd -0x18(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rsp)
movsd -0x10(%rsp), %xmm0
mulsd -0x20(%rsp), %xmm0
divsd -0x8(%rsp), %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x28(%rsp), %xmm0
movsd 0x5db0(%rip), %xmm1     # 0x1c178
ucomisd %xmm1, %xmm0
jbe 0x163ec
movsd -0x20(%rsp), %xmm0
movsd 0x5d9c(%rip), %xmm1     # 0x1c178
divsd -0x28(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rsp)
movsd -0x20(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/EvolveField.c
// Function: FindCMFTime(double)
double FindCMFTime(double tcurrent)
{
	int j;
	double res;
	const double CMFTimes[CMFTIMENUM] = CMFTIMEVALUES; //times at which CMF and IMF are saved. 
	//Find nearest CMF observation time
	res=-1.0;//init
	if(tcurrent<=CMFTimes[0]){
		res=CMFTimes[0];
	}
	else{
		for ( j = 1; j < CMFTIMENUM; j++ ){
			if(CMFTimes[j-1]<tcurrent && CMFTimes[j]>=tcurrent){ //between these values
				res=CMFTimes[j];
			}
		}
	}

	return res;
}

// Assembly:
subq $0x98, %rsp
movsd %xmm0, 0x90(%rsp)
movq %rsp, %rdi
leaq 0x61e6(%rip), %rsi      # 0x1c600
movl $0x80, %edx
callq 0x8540
movsd 0x5d34(%rip), %xmm0     # 0x1c160
movsd %xmm0, 0x80(%rsp)
movsd 0x90(%rsp), %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x16459
movsd (%rsp), %xmm0
movsd %xmm0, 0x80(%rsp)
jmp 0x164d3
movl $0x1, 0x8c(%rsp)
cmpl $0x10, 0x8c(%rsp)
jge 0x164d1
movl 0x8c(%rsp), %eax
subl $0x1, %eax
cltq
movsd (%rsp,%rax,8), %xmm1
movsd 0x90(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x164bc
movslq 0x8c(%rsp), %rax
movsd (%rsp,%rax,8), %xmm0
ucomisd 0x90(%rsp), %xmm0
jb 0x164bc
movslq 0x8c(%rsp), %rax
movsd (%rsp,%rax,8), %xmm0
movsd %xmm0, 0x80(%rsp)
jmp 0x164be
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x16464
jmp 0x164d3
movsd 0x80(%rsp), %xmm0
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/EvolveField.c
// Function: FindCMFTimeIndex(double)
long FindCMFTimeIndex(double tcurrent)
{
	int j;
	long res;
	const double CMFTimes[CMFTIMENUM] = CMFTIMEVALUES; //times at which CMF and IMF are saved. 
	//Find nearest CMF observation time
	res=-1;//init
	if(tcurrent<=CMFTimes[0]){
		res=0;
	}
	else{
		for ( j = 1; j < CMFTIMENUM; j++ ){
			if(CMFTimes[j-1]<tcurrent && CMFTimes[j]>=tcurrent){ //between these values
				res=j;
			}
		}
	}

	return res;
}

// Assembly:
subq $0x98, %rsp
movsd %xmm0, 0x90(%rsp)
movq %rsp, %rdi
leaq 0x6176(%rip), %rsi      # 0x1c680
movl $0x80, %edx
callq 0x8540
movq $-0x1, 0x80(%rsp)
movsd 0x90(%rsp), %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x16542
movq $0x0, 0x80(%rsp)
jmp 0x165b6
movl $0x1, 0x8c(%rsp)
cmpl $0x10, 0x8c(%rsp)
jge 0x165b4
movl 0x8c(%rsp), %eax
subl $0x1, %eax
cltq
movsd (%rsp,%rax,8), %xmm1
movsd 0x90(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1659f
movslq 0x8c(%rsp), %rax
movsd (%rsp,%rax,8), %xmm0
ucomisd 0x90(%rsp), %xmm0
jb 0x1659f
movslq 0x8c(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x165a1
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x1654d
jmp 0x165b6
movq 0x80(%rsp), %rax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/EvolveField.c
// Function: IsSelfGravitating(double, double, double, double, double, double)
inline bool IsSelfGravitating(double SphereMass, double TMean, double R, double MachedgeSq, double gamma, double StrictnessFactor){
    if( SphereMass >  StrictnessFactor*(FourPiOver3*pow(R,3.0)*RhoCrit(TMean,R,MachedgeSq, gamma)) ){ 
         return true;
         }
    else{
         return false;
         }
}

// Assembly:
subq $0x58, %rsp
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x40(%rsp)
movsd %xmm2, 0x38(%rsp)
movsd %xmm3, 0x30(%rsp)
movsd %xmm4, 0x28(%rsp)
movsd %xmm5, 0x20(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x5e2a(%rip), %xmm1     # 0x1c4f8
callq 0x8bc0
movaps %xmm0, %xmm1
movsd 0x5a8a(%rip), %xmm0     # 0x1c168
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
callq 0x16600
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movaps %xmm0, %xmm3
movsd 0x18(%rsp), %xmm0
mulsd %xmm3, %xmm2
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1672f
movb $0x1, 0x57(%rsp)
jmp 0x16734
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/InputDataManage.cpp
// Function: IncreaseInputStorage()
void IncreaseInputStorage(){
	long i;
	InputStorage=(struct inputstruct_s*) realloc(InputStorage, (NInputAllocated+StructIncreaseUnit)* sizeof(struct inputstruct_s));
	if(InputStorage==NULL){ //unsuccessful allocation
		cout<<"Memory allocation failure! Exiting!";
		exit(EXIT_FAILURE);
	}
	IsUsed=(bool*) realloc(IsUsed, (NInputAllocated+StructIncreaseUnit)*sizeof(bool));
	for(i=0;i<StructIncreaseUnit;i++){
		IsUsed[NInputAllocated+i]=false;
	}
    InputPriority=(double*) realloc(InputPriority, (NInputAllocated+StructIncreaseUnit)*sizeof(double));
	NInputAllocated+=StructIncreaseUnit; //note the number of elements
	cout<<"Input storage expanded to "<<NInputAllocated<<"\n";
}

// Assembly:
pushq %rax
movq 0xbff8(%rip), %rdi      # 0x22740
movq 0xc009(%rip), %rax      # 0x22758
addq $0x32, %rax
imulq $0x80050, %rax, %rsi    # imm = 0x80050
callq 0x8ae0
movq %rax, 0xbfda(%rip)      # 0x22740
cmpq $0x0, 0xbfd2(%rip)      # 0x22740
jne 0x1678d
movq 0xb859(%rip), %rdi      # 0x21fd0
leaq 0x5bc2(%rip), %rsi      # 0x1c340
callq 0x8640
movl $0x1, %edi
callq 0x87c0
movq 0xbfbc(%rip), %rdi      # 0x22750
movq 0xbfbd(%rip), %rsi      # 0x22758
addq $0x32, %rsi
shlq $0x0, %rsi
callq 0x8ae0
movq %rax, 0xbfa1(%rip)      # 0x22750
movq $0x0, (%rsp)
cmpq $0x32, (%rsp)
jge 0x167e2
movq 0xbf8b(%rip), %rax      # 0x22750
movq 0xbf8c(%rip), %rcx      # 0x22758
addq (%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x167b7
movq 0xbf5f(%rip), %rdi      # 0x22748
movq 0xbf68(%rip), %rsi      # 0x22758
addq $0x32, %rsi
shlq $0x3, %rsi
callq 0x8ae0
movq %rax, 0xbf44(%rip)      # 0x22748
movq 0xbf4d(%rip), %rax      # 0x22758
addq $0x32, %rax
movq %rax, 0xbf42(%rip)      # 0x22758
movq 0xb7b3(%rip), %rdi      # 0x21fd0
leaq 0x5edc(%rip), %rsi      # 0x1c700
callq 0x8640
movq %rax, %rdi
movq 0xbf25(%rip), %rsi      # 0x22758
callq 0x8c60
movq %rax, %rdi
leaq 0x5ae7(%rip), %rsi      # 0x1c329
callq 0x8640
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/InputDataManage.cpp
// Function: FreeInputStorage()
void FreeInputStorage(){
	NInputAllocated=0;
	NInputCurrent=0;
	free(InputStorage);
	free(IsUsed);
	free(InputPriority);
}

// Assembly:
pushq %rax
movq $0x0, 0xbefc(%rip) # 0x22758
movq $0x0, 0xbef9(%rip) # 0x22760
movq 0xbed2(%rip), %rdi      # 0x22740
callq 0x8780
movq 0xbed6(%rip), %rdi      # 0x22750
callq 0x8780
movq 0xbec2(%rip), %rdi      # 0x22748
callq 0x8780
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/InputDataManage.cpp
// Function: SaveAndFreeInputStorage()
void SaveAndFreeInputStorage(){
	char filename[200];
	
	//Get filename
	ContructFilePath("Restart_Inputs.txt", "Output", filename);
	//Save all accumulated input data
	SaveInputStorage(filename);
	FreeInputStorage(); //free memory
}

// Assembly:
subq $0xc8, %rsp
movq %rsp, %rdx
leaq 0x5972(%rip), %rdi      # 0x1c213
leaq 0x58e0(%rip), %rsi      # 0x1c188
callq 0x173f0
movq %rsp, %rdi
callq 0x168d0
callq 0x16850
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/InputDataManage.cpp
// Function: InitInputDataType()
void InitInputDataType(){

//MPI Variables
const int nitems=12; //number of items in the structure	
int blocklengths[12]={NgridTotal,NgridTotal,1,1,1,1,1,1,1,1,1,1}; //length of struct blocks
MPI_Datatype types[12] = {MPI_DOUBLE, MPI_DOUBLE,MPI_DOUBLE, MPI_DOUBLE,MPI_DOUBLE, MPI_DOUBLE,MPI_DOUBLE, MPI_DOUBLE,MPI_DOUBLE, MPI_DOUBLE,MPI_DOUBLE, MPI_DOUBLE}; //type of variables in blocks
MPI_Aint offsets[12]; //memory offsets for each block	

//Find offsets of input datatype
offsets[0] = offsetof(inputstruct_s,rho_field);
offsets[1] = offsetof(inputstruct_s, T_field);
offsets[2] = offsetof(inputstruct_s, R0);
offsets[3] = offsetof(inputstruct_s, X0);
offsets[4] = offsetof(inputstruct_s, Y0);
offsets[5] = offsetof(inputstruct_s, Z0);
offsets[6] = offsetof(inputstruct_s, Machedge);
offsets[7] = offsetof(inputstruct_s, RelativeVelocityX);
offsets[8] = offsetof(inputstruct_s, RelativeVelocityY);
offsets[9] = offsetof(inputstruct_s, RelativeVelocityZ);
offsets[10] = offsetof(inputstruct_s, InitScale);
offsets[11] = offsetof(inputstruct_s, tparent);


//create MPI passable struct type
MPI_Type_create_struct(nitems, blocklengths, offsets, types, &mpi_inputstruct_type); 
//allows the type to be used for MPI communication
MPI_Type_commit(&mpi_inputstruct_type); 

	
}

// Assembly:
subq $0xf8, %rsp
movl $0xc, 0xf4(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x56ff(%rip), %rsi      # 0x1c740
movl $0x30, %edx
callq 0x8540
leaq 0x60(%rsp), %rdi
leaq 0xac79(%rip), %rsi      # 0x21cd0
movl $0x60, %edx
callq 0x8540
movq $0x0, (%rsp)
movq $0x40000, 0x8(%rsp)     # imm = 0x40000
movq $0x80000, 0x10(%rsp)    # imm = 0x80000
movq $0x80008, 0x18(%rsp)    # imm = 0x80008
movq $0x80010, 0x20(%rsp)    # imm = 0x80010
movq $0x80018, 0x28(%rsp)    # imm = 0x80018
movq $0x80020, 0x30(%rsp)    # imm = 0x80020
movq $0x80028, 0x38(%rsp)    # imm = 0x80028
movq $0x80030, 0x40(%rsp)    # imm = 0x80030
movq $0x80038, 0x48(%rsp)    # imm = 0x80038
movq $0x80040, 0x50(%rsp)    # imm = 0x80040
movq $0x80048, 0x58(%rsp)    # imm = 0x80048
leaq 0xc0(%rsp), %rsi
movq %rsp, %rdx
leaq 0x60(%rsp), %rcx
movl $0xc, %edi
leaq 0xb648(%rip), %r8       # 0x22730
callq 0x86a0
leaq 0xb63c(%rip), %rdi      # 0x22730
callq 0x8810
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/InputDataManage.cpp
// Function: InitDensityStructDataType()
void InitDensityStructDataType(){
//MPI Variables
const int nitems=6; //number of items in the structure	
int blocklengths[6]={NgridTotal,NgridTotal,NgridTotal,NgridTotal,NgridTotal,1}; //length of struct blocks
MPI_Datatype types[6] = {MPI_DOUBLE, MPI_DOUBLE,MPI_DOUBLE, MPI_DOUBLE,MPI_DOUBLE, MPI_DOUBLE}; //type of variables in blocks
MPI_Aint offsets[6]; //memory offsets for each block	

//Find offsets of input datatype
offsets[0] = offsetof(densitystruct_s,rho_field);
offsets[1] = offsetof(densitystruct_s, T_field);
offsets[2] = offsetof(densitystruct_s, xcoord);
offsets[3] = offsetof(densitystruct_s, ycoord);
offsets[4] = offsetof(densitystruct_s, zcoord);
offsets[5] = offsetof(densitystruct_s, volume);



//create MPI passable struct type
MPI_Type_create_struct(nitems, blocklengths, offsets, types, &mpi_densitystruct_type); 
//allows the type to be used for MPI communication
MPI_Type_commit(&mpi_densitystruct_type); 

	
}

// Assembly:
subq $0x88, %rsp
movl $0x6, 0x84(%rsp)
movq 0x5647(%rip), %rax      # 0x1c770
movq %rax, 0x60(%rsp)
movq 0x5643(%rip), %rax      # 0x1c778
movq %rax, 0x68(%rsp)
movq 0x563f(%rip), %rax      # 0x1c780
movq %rax, 0x70(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0xabde(%rip), %rsi      # 0x21d30
movl $0x30, %edx
callq 0x8540
movq $0x0, (%rsp)
movq $0x40000, 0x8(%rsp)     # imm = 0x40000
movq $0x80000, 0x10(%rsp)    # imm = 0x80000
movq $0xc0000, 0x18(%rsp)    # imm = 0xC0000
movq $0x100000, 0x20(%rsp)   # imm = 0x100000
movq $0x140000, 0x28(%rsp)   # imm = 0x140000
leaq 0x60(%rsp), %rsi
movq %rsp, %rdx
leaq 0x30(%rsp), %rcx
movl $0x6, %edi
leaq 0xb58e(%rip), %r8       # 0x22738
callq 0x86a0
leaq 0xb582(%rip), %rdi      # 0x22738
callq 0x8810
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/InputDataManage.cpp
// Function: InitInputDataStorage(long)
void InitInputDataStorage(long Nitem)
{
	//Init global counting variables
	NInputAllocated=Nitem;
	NInputCurrent=0;
	InputStorage=(struct inputstruct_s*) calloc(Nitem,sizeof(struct inputstruct_s));
	if(InputStorage==NULL){ //unsuccessful allocation
		cout<<"Memory allocation failure! Exiting!";
		exit(EXIT_FAILURE);
	}
    IsUsed=vector_bool(Nitem);
    InputPriority=vector_double(Nitem);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq %rax, 0xb578(%rip)      # 0x22758
movq $0x0, 0xb575(%rip) # 0x22760
movq (%rsp), %rdi
movl $0x80050, %esi          # imm = 0x80050
callq 0x83b0
movq %rax, 0xb540(%rip)      # 0x22740
cmpq $0x0, 0xb538(%rip)      # 0x22740
jne 0x17227
movq 0xadbf(%rip), %rdi      # 0x21fd0
leaq 0x5128(%rip), %rsi      # 0x1c340
callq 0x8640
movl $0x1, %edi
callq 0x87c0
movq (%rsp), %rdi
callq 0x1b310
movq %rax, 0xb519(%rip)      # 0x22750
movq (%rsp), %rdi
callq 0x1b2b0
movq %rax, 0xb501(%rip)      # 0x22748
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/InputDataManage.cpp
// Function: NextToCall()
long NextToCall(){
	long i,ind=-1;
	double temp=0;
	
	for(i=0;i<NInputAllocated;i++){
		if(IsUsed[i]){
			if(ind==-1){
				ind=i;
				temp=InputPriority[i];
			}
			else{
				if(InputPriority[i]>temp){
					ind=i;
					temp=InputPriority[i];
				}
			}
			
		}
    }
    
    return ind;	
}

// Assembly:
movq $-0x1, -0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
cmpq 0xb4e1(%rip), %rax      # 0x22758
jge 0x1730d
movq 0xb4cc(%rip), %rax      # 0x22750
movq -0x8(%rsp), %rcx
testb $0x1, (%rax,%rcx)
je 0x172f8
cmpq $-0x1, -0x10(%rsp)
jne 0x172ba
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq 0xb4a0(%rip), %rax      # 0x22748
movq -0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rsp)
jmp 0x172f6
movq 0xb487(%rip), %rax      # 0x22748
movq -0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x18(%rsp), %xmm0
jbe 0x172f4
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq 0xb464(%rip), %rax      # 0x22748
movq -0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rsp)
jmp 0x172f6
jmp 0x172f8
jmp 0x172fa
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0x1726b
movq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/InputDataManage.cpp
// Function: FirstUnused()
long FirstUnused(){
	long i;
	for(i=0;i<NInputAllocated;i++){
		if(IsUsed[i]==false){
			return i;
		}
	}
	cout<<"All of InputStorage used.";
	return -1; //error
}

// Assembly:
subq $0x18, %rsp
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0xb41f(%rip), %rax      # 0x22758
jge 0x17372
movq 0xb40e(%rip), %rax      # 0x22750
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x17360
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1738e
jmp 0x17362
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1732d
movq 0xac57(%rip), %rdi      # 0x21fd0
leaq 0x539b(%rip), %rsi      # 0x1c71b
callq 0x8640
movq $-0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/FileManage.c
// Function: file_exists(char*)
bool file_exists (char* filename) {
    if (FILE *file = fopen(filename, "r")) {
        fclose(file);
        return true;
    } else {
        return false;
    }   
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x53d3(%rip), %rsi      # 0x1c788
callq 0x8770
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x173d5
movq (%rsp), %rdi
callq 0x8650
movb $0x1, 0x17(%rsp)
jmp 0x173da
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/FileManage.c
// Function: WriteLineToTextFile(char*, char*)
void WriteLineToTextFile(char* line, char* filename)
{
	FILE *targetfile; //input file handle
    //Open file
    targetfile = fopen (filename,"a");
    //Save line to file
	fprintf(targetfile,"%s\n",line);
	fflush(targetfile);
	fclose(targetfile);		
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x5327(%rip), %rsi      # 0x1c791
callq 0x8770
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x5310(%rip), %rsi      # 0x1c793
movb $0x0, %al
callq 0x89a0
movq (%rsp), %rdi
callq 0x8760
movq (%rsp), %rdi
callq 0x8650
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/FileManage.c
// Function: CountNumberOfLines(char*)
long CountNumberOfLines(char* filename){
	
FILE *fp = fopen(filename,"r");
int ch=0;
long lines=0;

while(!feof(fp))
{
  ch = fgetc(fp);
  if(ch == '\n')
  {
    lines++;
  }
}

return lines;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x52c3(%rip), %rsi      # 0x1c788
callq 0x8770
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8a10
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x174f8
jmp 0x1751d
movq 0x18(%rsp), %rdi
callq 0x8a60
movl %eax, 0x14(%rsp)
cmpl $0xa, 0x14(%rsp)
jne 0x1751b
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x174e0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/comparison.c
// Function: InLimits_double(double, double, double)
double InLimits_double(double a, double xmin, double xmax)
{
    if (a>xmax){
       return xmax;
       }
       else
       {
         if(a<xmin){
                return xmin;
                }
         else
         {
           return a;
          }
       }
}

// Assembly:
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd %xmm2, -0x20(%rsp)
movsd -0x10(%rsp), %xmm0
ucomisd -0x20(%rsp), %xmm0
jbe 0x1765e
movsd -0x20(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x1768a
movsd -0x10(%rsp), %xmm1
movsd -0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1767e
movsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x1768a
movsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/comparison.c
// Function: Min_array_double(double*, long)
double Min_array_double(double* x, long N)
{
long i;
double res;

res=x[0]; //init
 for (i = 0; i < N; i++){
     if (x[i]>res){
        res=x[i];
        }
     }
 return res;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x10(%rsp), %rax
jge 0x1770c
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x20(%rsp), %xmm0
jbe 0x176fa
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rsp)
jmp 0x176fc
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x176c2
movsd -0x20(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/Deriv_func.c
// Function: Deriv_func(double, double*, double*, double, long)
void Deriv_func ( double t, double y[], double yp[], double dt, long dimension )

/******************************************************************************/
/*
  Purpose:
  		  
    Evaluates the derivative, using equation for scalar size
*/
{
   /*Calculating derivative*/ 
   // In this case y[0]= r relative radius, y[1]=sigma surface density, y[2]=edge Mach number at the beginning, y[3] is the current edge Mach number squared
      // d r/d tau=1/(1-Q/2) -1/sqrt(r) Mach^3/(1+Mach^2)^(3/2)*sqrt(M/M_0), see http://arxiv.org/abs/1507.06678 (last correction factor accounts for mass loss)
   //Safegurad against negative values which cause problems
   if(y[0]>0){
   	yp[0]=-1.0/(1.0-QVirial/2.0)*pow(y[0],-0.5)*pow(y[2]/(1.0+y[2]),1.5)*sqrt(y[3]);
      // Sigma, evolved separetely
    yp[1]=0.0;
     // Edge Mach number, evolved separetely
   	yp[2]=0.0;
     // Mass ratio, evolved separetely
   	yp[3]=0.0;
   }
   else{
   	yp[0]=0;
   	yp[1]=0;
   	yp[2]=0;
   	yp[3]=0;
   }
   
   
  return;
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1788c
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x4fba(%rip), %xmm1     # 0x1c7a0
callq 0x8bc0
movaps %xmm0, %xmm1
movsd 0x4fa2(%rip), %xmm0     # 0x1c798
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x28(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x28(%rsp), %rax
movsd 0x4942(%rip), %xmm1     # 0x1c158
addsd 0x10(%rax), %xmm1
divsd %xmm1, %xmm0
movsd 0x4c89(%rip), %xmm1     # 0x1c4b0
callq 0x8bc0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rax
movsd 0x18(%rax), %xmm0
callq 0x84b0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
jmp 0x178bf
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/fft.c
// Function: fft(complex*, int, int)
void fft(complex x[], int n, int flag)
{
   complex *y;
   
   assert(1 == flag || -1 == flag);
   y = (complex *) malloc( n*sizeof(complex) );
   assert(NULL != y);
   stockham(x, n, flag, 1, y);
   free(y);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movb $0x1, %al
movl $0x1, %ecx
cmpl 0x18(%rsp), %ecx
movb %al, 0xf(%rsp)
je 0x18172
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x18(%rsp), %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1817c
jmp 0x1817e
jmp 0x1819d
leaq 0x46b5(%rip), %rdi      # 0x1c83a
leaq 0x462f(%rip), %rsi      # 0x1c7bb
movl $0xbb, %edx
leaq 0x46ba(%rip), %rcx      # 0x1c852
callq 0x83a0
movslq 0x1c(%rsp), %rdi
shlq $0x4, %rdi
callq 0x8890
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
je 0x181bb
jmp 0x181da
leaq 0x46ae(%rip), %rdi      # 0x1c870
leaq 0x45f2(%rip), %rsi      # 0x1c7bb
movl $0xbd, %edx
leaq 0x467d(%rip), %rcx      # 0x1c852
callq 0x83a0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
movq 0x10(%rsp), %r8
movl $0x1, %ecx
callq 0x178d0
movq 0x10(%rsp), %rdi
callq 0x8780
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/fft.c
// Function: fft2D(complex*, int, int, int)
void fft2D(complex x[], int n1, int n2, int flag)
{
   complex *y;
   int i, n;

   assert(1 == flag || -1 == flag);
   n = n1*n2;
   y = (complex *) malloc( n2*sizeof(complex) );
   assert(NULL != y);

   for(i=0; i < n; i += n2) {                                  /* FFT in y */
      stockham(x+i, n2, flag, 1, y); 
   }
   free(y);
   cooley_tukey(x, n, flag, n2);                               /* FFT in x */
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movb $0x1, %al
movl $0x1, %ecx
cmpl 0x24(%rsp), %ecx
movb %al, 0xf(%rsp)
je 0x18246
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x24(%rsp), %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x18250
jmp 0x18252
jmp 0x18271
leaq 0x45e1(%rip), %rdi      # 0x1c83a
leaq 0x455b(%rip), %rsi      # 0x1c7bb
movl $0xd2, %edx
leaq 0x460e(%rip), %rcx      # 0x1c87a
callq 0x83a0
movl 0x2c(%rsp), %eax
imull 0x28(%rsp), %eax
movl %eax, 0x10(%rsp)
movslq 0x28(%rsp), %rdi
shlq $0x4, %rdi
callq 0x8890
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
je 0x1829c
jmp 0x182bb
leaq 0x45cd(%rip), %rdi      # 0x1c870
leaq 0x4511(%rip), %rsi      # 0x1c7bb
movl $0xd5, %edx
leaq 0x45c4(%rip), %rcx      # 0x1c87a
callq 0x83a0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x18303
movq 0x30(%rsp), %rdi
movslq 0x14(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %r8
movl $0x1, %ecx
callq 0x178d0
movl 0x28(%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x182c3
movq 0x18(%rsp), %rdi
callq 0x8780
movq 0x30(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0x24(%rsp), %edx
movl 0x28(%rsp), %ecx
callq 0x17cd0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/fft.c
// Function: fft3D(complex*, int, int, int, int)
void fft3D(complex x[], int n1, int n2, int n3, int flag)
{
   complex *y;
   int i, n, n23;

   assert(1 == flag || -1 == flag);
   n23 = n2*n3;
   n = n1*n23;
   y = (complex *) malloc( n23*sizeof(complex) );
   assert(NULL != y);

   for(i=0; i < n; i += n3) {                                  /* FFT in z */
      stockham(x+i, n3, flag, 1, y);
   }
   for(i=0; i < n; i += n23) {                                 /* FFT in y */
      stockham(x+i, n23, flag, n3, y); 
   }
   free(y);
   cooley_tukey(x, n, flag, n23);                              /* FFT in x */
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movb $0x1, %al
movl $0x1, %ecx
cmpl 0x20(%rsp), %ecx
movb %al, 0xb(%rsp)
je 0x1836b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x20(%rsp), %eax
sete %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x18375
jmp 0x18377
jmp 0x18396
leaq 0x44bc(%rip), %rdi      # 0x1c83a
leaq 0x4436(%rip), %rsi      # 0x1c7bb
movl $0xe3, %edx
leaq 0x450e(%rip), %rcx      # 0x1c89f
callq 0x83a0
movl 0x28(%rsp), %eax
imull 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x2c(%rsp), %eax
imull 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
movslq 0xc(%rsp), %rdi
shlq $0x4, %rdi
callq 0x8890
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
je 0x183ce
jmp 0x183ed
leaq 0x449b(%rip), %rdi      # 0x1c870
leaq 0x43df(%rip), %rsi      # 0x1c7bb
movl $0xe7, %edx
leaq 0x44b7(%rip), %rcx      # 0x1c89f
callq 0x83a0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x18435
movq 0x30(%rsp), %rdi
movslq 0x14(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %r8
movl $0x1, %ecx
callq 0x178d0
movl 0x24(%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x183f5
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x1847c
movq 0x30(%rsp), %rdi
movslq 0x14(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movl 0xc(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %r8
callq 0x178d0
movl 0xc(%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x1843d
movq 0x18(%rsp), %rdi
callq 0x8780
movq 0x30(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x17cd0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/gaussrand.c
// Function: gaussrand()
double gaussrand()
{
	static double V1, V2, S;
	static int phase = 0;
	double X;

	if(phase == 0) {
		do {
			double U1 = (double)rand() / RAND_MAX;
			double U2 = (double)rand() / RAND_MAX;

			V1 = 2 * U1 - 1;
			V2 = 2 * U2 - 1;
			S = V1 * V1 + V2 * V2;
			} while(S >= 1 || S == 0);

		X = V1 * sqrt(-2 * log(S) / S);
	} else
		X = V2 * sqrt(-2 * log(S) / S);

	phase = 1 - phase;

	return X;
}

// Assembly:
subq $0x38, %rsp
cmpl $0x0, 0x9d15(%rip)      # 0x22780
jne 0x18ba4
jmp 0x18a73
callq 0x8190
cvtsi2sd %eax, %xmm0
movsd 0x3ecc(%rip), %xmm1     # 0x1c950
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
callq 0x8190
cvtsi2sd %eax, %xmm0
movsd 0x3eb1(%rip), %xmm1     # 0x1c950
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
addsd %xmm0, %xmm0
movsd 0x36a5(%rip), %xmm1     # 0x1c160
addsd %xmm1, %xmm0
movsd %xmm0, 0x9ca1(%rip)     # 0x22768
movsd 0x20(%rsp), %xmm0
addsd %xmm0, %xmm0
movsd 0x3687(%rip), %xmm1     # 0x1c160
addsd %xmm1, %xmm0
movsd %xmm0, 0x9c8b(%rip)     # 0x22770
movsd 0x9c7b(%rip), %xmm0     # 0x22768
movsd 0x9c73(%rip), %xmm2     # 0x22768
movsd 0x9c73(%rip), %xmm1     # 0x22770
mulsd 0x9c6b(%rip), %xmm1     # 0x22770
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x9c63(%rip)     # 0x22778
movsd 0x9c5b(%rip), %xmm0     # 0x22778
movb $0x1, %al
movsd 0x3631(%rip), %xmm1     # 0x1c158
ucomisd %xmm1, %xmm0
movb %al, 0x1f(%rsp)
jae 0x18b4c
movsd 0x9c3f(%rip), %xmm0     # 0x22778
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x18a73
movsd 0x9c08(%rip), %xmm0     # 0x22768
movsd %xmm0, 0x10(%rsp)
movsd 0x9c0a(%rip), %xmm0     # 0x22778
callq 0x84f0
movaps %xmm0, %xmm1
movsd 0x3dca(%rip), %xmm0     # 0x1c948
mulsd %xmm1, %xmm0
divsd 0x9bee(%rip), %xmm0     # 0x22778
callq 0x84b0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x18bee
movsd 0x9bc4(%rip), %xmm0     # 0x22770
movsd %xmm0, 0x8(%rsp)
movsd 0x9bbe(%rip), %xmm0     # 0x22778
callq 0x84f0
movaps %xmm0, %xmm1
movsd 0x3d7e(%rip), %xmm0     # 0x1c948
mulsd %xmm1, %xmm0
divsd 0x9ba2(%rip), %xmm0     # 0x22778
callq 0x84b0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x1, %eax
subl 0x9b87(%rip), %eax      # 0x22780
movl %eax, 0x9b81(%rip)      # 0x22780
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/LogScale.c
// Function: LogScale(double*, double, double, long)
void LogScale(double* vector, double x0, double x1, long n)
{
long i; //loop variable
double step=log(x1/x0)/(n-1);
double logx0=log(x0);

for (i = 0; i < n; i++){
    vector[i]=exp(logx0+i*step);
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
divsd 0x28(%rsp), %xmm0
callq 0x84f0
movq 0x18(%rsp), %rax
subq $0x1, %rax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x84f0
movsd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jge 0x18cb6
movsd (%rsp), %xmm1
cvtsi2sdq 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x8c00
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x18c6c
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/Restart.cpp
// Function: SaveRestartControl(long)
void SaveRestartControl(long Niter){
	ofstream myfile; //Output file handle
	char filename[200];
	
	//Get filename
	ContructFilePath("RestartControl.txt", "Output", filename);
	//open output file
	myfile.open(filename,ios::out);
    //Save parameters
    myfile<<Niter<<"\n";
    myfile.flush(); //finish writing
    myfile.close(); //close file
}

// Assembly:
subq $0x2f8, %rsp            # imm = 0x2F8
movq %rdi, 0x2f0(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x8b80
leaq 0x3010(%rip), %rdi      # 0x1c1e3
leaq 0x2fae(%rip), %rsi      # 0x1c188
leaq 0x20(%rsp), %rdx
callq 0x173f0
jmp 0x191e6
leaq 0xf0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x10, %edx
callq 0x8060
jmp 0x191ff
movq 0x2f0(%rsp), %rsi
leaq 0xf0(%rsp), %rdi
callq 0x8c60
movq %rax, 0x8(%rsp)
jmp 0x1921b
movq 0x8(%rsp), %rdi
leaq 0x3102(%rip), %rsi      # 0x1c329
callq 0x8640
jmp 0x1922e
leaq 0xf0(%rsp), %rdi
callq 0x83e0
jmp 0x1923d
leaq 0xf0(%rsp), %rdi
callq 0x8960
jmp 0x1924c
leaq 0xf0(%rsp), %rdi
callq 0x89c0
addq $0x2f8, %rsp            # imm = 0x2F8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x89c0
movq 0x18(%rsp), %rdi
callq 0x8be0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/Restart.cpp
// Function: ReadRestartControl(long*)
void ReadRestartControl(long* Niter){
	char filename[200];
	FILE *sourcefile; //Input file handle
	char line[100];
	
	//Get filename
	ContructFilePath("RestartControl.txt", "Output", filename);
	//open input file
	sourcefile=fopen (filename,"r");
    //Read parameters
    fgets (line, 100, sourcefile);
    Niter[0]=strtol(line,NULL, 0);
    fclose(sourcefile);
    remove(filename); //remove file
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x140(%rsp)
leaq 0x70(%rsp), %rdx
leaq 0x2f38(%rip), %rdi      # 0x1c1e3
leaq 0x2ed6(%rip), %rsi      # 0x1c188
callq 0x173f0
leaq 0x70(%rsp), %rdi
leaq 0x34c5(%rip), %rsi      # 0x1c788
callq 0x8770
movq %rax, 0x68(%rsp)
movq %rsp, %rdi
movq 0x68(%rsp), %rdx
movl $0x64, %esi
callq 0x8a70
movq %rsp, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x8910
movq %rax, %rcx
movq 0x140(%rsp), %rax
movq %rcx, (%rax)
movq 0x68(%rsp), %rdi
callq 0x8650
leaq 0x70(%rsp), %rdi
callq 0x8c10
addq $0x148, %rsp            # imm = 0x148
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: vector_long(long)
long *vector_long(long m) {
    long *res = (long *) calloc(m, sizeof (long));
    if (res == NULL){
    	cout<<"Error! Failed memory allocation in" <<"vector_long"<<" function.\n";
	}
    return (res);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x83b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1b1e6
movq 0x6e14(%rip), %rdi      # 0x21fd0
leaq 0x17a5(%rip), %rsi      # 0x1c968
callq 0x8640
movq %rax, %rdi
leaq 0x17b9(%rip), %rsi      # 0x1c98b
callq 0x8640
movq %rax, %rdi
leaq 0x17b6(%rip), %rsi      # 0x1c997
callq 0x8640
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: matrix_long(long, long)
long **matrix_long(long m, long n) {
    long **res = (long **) calloc(m, sizeof (long *));
    long i;
    for (i = 0; i < m; i++)
        res[i] = (long *) calloc(n, sizeof (long));
    	if (res[i] == NULL){
    		cout<<"Error! Failed memory allocation in" <<"matrix_long"<<" function.\n";
		}
    return (res);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x8, %esi
callq 0x83b0
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jge 0x1b257
movq 0x18(%rsp), %rdi
movl $0x8, %esi
callq 0x83b0
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1b21b
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1b299
movq 0x6d61(%rip), %rdi      # 0x21fd0
leaq 0x16f2(%rip), %rsi      # 0x1c968
callq 0x8640
movq %rax, %rdi
leaq 0x171e(%rip), %rsi      # 0x1c9a3
callq 0x8640
movq %rax, %rdi
leaq 0x1703(%rip), %rsi      # 0x1c997
callq 0x8640
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: vector_double(long)
double *vector_double(long m) {
    double *res = (double *) calloc(m, sizeof (double));
    if (res == NULL){
    	cout<<"Error! Failed memory allocation in" <<"vector_double"<<" function.\n";
	}
    return (res);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x83b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1b306
movq 0x6cf4(%rip), %rdi      # 0x21fd0
leaq 0x1685(%rip), %rsi      # 0x1c968
callq 0x8640
movq %rax, %rdi
leaq 0x16bd(%rip), %rsi      # 0x1c9af
callq 0x8640
movq %rax, %rdi
leaq 0x1696(%rip), %rsi      # 0x1c997
callq 0x8640
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: vector_bool(long)
bool *vector_bool(long m) {
    bool *res = (bool *) calloc(m, sizeof (bool));
    if (res == NULL){
    	cout<<"Error! Failed memory allocation in" <<"vector_bool"<<" function.\n";
	}
    return (res);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x83b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1b366
movq 0x6c94(%rip), %rdi      # 0x21fd0
leaq 0x1625(%rip), %rsi      # 0x1c968
callq 0x8640
movq %rax, %rdi
leaq 0x166b(%rip), %rsi      # 0x1c9bd
callq 0x8640
movq %rax, %rdi
leaq 0x1636(%rip), %rsi      # 0x1c997
callq 0x8640
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: matrix_double(long, long)
double **matrix_double(long m, long n) {
    double **res = (double **) calloc(m, sizeof (double *));
    long i;
    for (i = 0; i < m; i++)
        res[i] = (double *) calloc(n, sizeof (double));
        if (res[i] == NULL){
    		cout<<"Error! Failed memory allocation in" <<"matrix_double"<<" function.\n";
		}
    return (res);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x8, %esi
callq 0x83b0
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jge 0x1b3d7
movq 0x18(%rsp), %rdi
movl $0x8, %esi
callq 0x83b0
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1b39b
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1b419
movq 0x6be1(%rip), %rdi      # 0x21fd0
leaq 0x1572(%rip), %rsi      # 0x1c968
callq 0x8640
movq %rax, %rdi
leaq 0x15c4(%rip), %rsi      # 0x1c9c9
callq 0x8640
movq %rax, %rdi
leaq 0x1583(%rip), %rsi      # 0x1c997
callq 0x8640
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: matrix3d_double(long, long, long)
double ***matrix3d_double(long m, long n, long o){
       long i,j;
       double ***res = (double ***)calloc(m, sizeof(double**));
       for (i = 0; i< m; i++) {
         res[i] = (double **) calloc(n, sizeof(double*));
         for (j = 0; j < n; j++) {
              res[i][j] = (double *)calloc(o, sizeof(double));
            if (res[i][j] == NULL){
    			cout<<"Error! Failed memory allocation in" <<"matrix3d_double"<<" function.\n";
			}
          }
        }
       return (res);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x8, %esi
callq 0x83b0
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
jge 0x1b547
movq 0x28(%rsp), %rdi
movl $0x8, %esi
callq 0x83b0
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
jge 0x1b532
movq 0x20(%rsp), %rdi
movl $0x8, %esi
callq 0x83b0
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1b51d
movq 0x6add(%rip), %rdi      # 0x21fd0
leaq 0x146e(%rip), %rsi      # 0x1c968
callq 0x8640
movq %rax, %rdi
leaq 0x14ce(%rip), %rsi      # 0x1c9d7
callq 0x8640
movq %rax, %rdi
leaq 0x147f(%rip), %rsi      # 0x1c997
callq 0x8640
jmp 0x1b51f
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1b499
jmp 0x1b534
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1b460
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: free_long_matrix(long**, long)
void free_long_matrix(long** M, long m){
     long i;
     for (i = 0; i < m; i++){
         free(M[i]);
         }
         free(M);   
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jge 0x1b5a1
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8780
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1b576
movq 0x10(%rsp), %rdi
callq 0x8780
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: free_double_matrix(double**, long)
void free_double_matrix(double** M, long m){
     long i;
     for (i = 0; i < m; i++){
         free(M[i]);
         }
         free(M);   
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jge 0x1b5f1
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8780
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1b5c6
movq 0x10(%rsp), %rdi
callq 0x8780
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: free_double_matrix3d(double***, long, long)
void free_double_matrix3d(double*** M, long m, long n){
       long i,j;
       for (i = 0; i< m; i++) {
         for (j = 0; j < n; j++) {
              free(M[i][j]);
          }
          free(M[i]);
        }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jge 0x1b687
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jge 0x1b664
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8780
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1b630
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8780
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1b61c
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: vector_set(double*, double, long)
void vector_set( double x[], double a, long n_elements )
{
 	 //adds up vector plus constant
 	   long i;	     
 	   for(i=0;i<n_elements;i++){
	   							 x[i]=a;	   
 	   
	   }
	   return;
	   }

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x18(%rsp), %rax
jge 0x1b6da
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x1b6a9
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: vector_const_add(double*, double*, double, long)
void vector_const_add( double res[], double x[], double a, long n_elements )
{
 	 //adds up vector plus constant
 	   long i;	     
 	   for(i=0;i<n_elements;i++){
	   							 res[i]=x[i]+a;	   
 	   
	   }
	   return;
	   }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movsd %xmm0, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x1b73e
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x1b6fe
retq
nop
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: vector_add(double*, double*, double*, long)
void vector_add( double res[], double x1[], double x2[], long n_elements )
{
 	 //adds up two arrays
 	   long i;	     
 	   for(i=0;i<n_elements;i++){
	   							 res[i]=x1[i]+x2[i];	   
 	   
	   }
	   return;
	   }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x1b7a6
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x1b75d
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: vector_const_multiply(double*, double*, double, long)
void vector_const_multiply( double res[], double x[], double factor, long n_elements )
{
 	 //multiplies array with constant
 	   long i;	     
 	   for(i=0;i<n_elements;i++){
	   							 res[i]=x[i]*factor;	   
 	   
	   }
	   return;
	   }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movsd %xmm0, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x1b80e
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd -0x18(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x1b7ce
retq
nop