LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/guszejnovdavid[P]MISFIT/InputDataManage.cpp
// Function: FreeInputStorage()
void FreeInputStorage(){
	NInputAllocated=0;
	NInputCurrent=0;
	free(InputStorage);
	free(IsUsed);
	free(InputPriority);
}

// Assembly:
pushq %rax
xorl %eax, %eax
movq %rax, 0x7907(%rip)      # 0xf298
movq %rax, 0x7908(%rip)      # 0xf2a0
movq 0x78e1(%rip), %rdi      # 0xf280
callq 0x2250
movq 0x78e5(%rip), %rdi      # 0xf290
callq 0x2250
movq 0x78d1(%rip), %rdi      # 0xf288
popq %rax
jmp 0x2250
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
subq $0xd0, %rsp
leaq 0x3757(%rip), %rdi      # 0xb123
leaq 0x36c5(%rip), %rsi      # 0xb098
movq %rsp, %rbx
movq %rbx, %rdx
callq 0x807d
movq %rbx, %rdi
callq 0x79f4
callq 0x7987
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/guszejnovdavid[P]MISFIT/InputDataManage.cpp
// Function: PutIntoInputStorage(inputstruct_s*, long)
void PutIntoInputStorage(struct inputstruct_s* inputstruct, long pos_index){
	long i;
	
	//Rho
	for(i=0;i<NgridTotal;i++){
		InputStorage[pos_index].rho_field[i]=inputstruct[0].rho_field[i];
    }
	//T
	for(i=0;i<NgridTotal;i++){
		InputStorage[pos_index].T_field[i]=inputstruct[0].T_field[i];
    }
    InputStorage[pos_index].R0=inputstruct[0].R0;
    InputStorage[pos_index].X0=inputstruct[0].X0;
    InputStorage[pos_index].Y0=inputstruct[0].Y0;
    InputStorage[pos_index].Z0=inputstruct[0].Z0;
    InputStorage[pos_index].Machedge=inputstruct[0].Machedge;
    InputStorage[pos_index].RelativeVelocityX=inputstruct[0].RelativeVelocityX;
    InputStorage[pos_index].RelativeVelocityY=inputstruct[0].RelativeVelocityY;
    InputStorage[pos_index].RelativeVelocityZ=inputstruct[0].RelativeVelocityZ;
    InputStorage[pos_index].InitScale=inputstruct[0].InitScale;
    InputStorage[pos_index].tparent=inputstruct[0].tparent;
    
    //Assigned values
    IsUsed[pos_index]=true; //space occupied
    InputPriority[pos_index]=PriorityFunction(inputstruct);
    //InputPriority[pos_index]=1.0/inputstruct.R0;
    
	NInputCurrent++; //one more input struct has been added
}

// Assembly:
movq 0x757c(%rip), %rax      # 0xf280
imulq $0x80050, %rsi, %rcx    # imm = 0x80050
leaq (%rax,%rcx), %rdx
xorl %r8d, %r8d
movsd (%rdi,%r8,8), %xmm0
movsd %xmm0, (%rdx,%r8,8)
incq %r8
cmpq $0x8000, %r8            # imm = 0x8000
jne 0x7d12
leaq (%rcx,%rax), %rdx
addq $0x40000, %rdx          # imm = 0x40000
xorl %r8d, %r8d
movsd 0x40000(%rdi,%r8,8), %xmm0
movsd %xmm0, (%rdx,%r8,8)
incq %r8
cmpq $0x8000, %r8            # imm = 0x8000
jne 0x7d38
movupd 0x80000(%rdi), %xmm0
movupd %xmm0, 0x80000(%rax,%rcx)
movups 0x80010(%rdi), %xmm1
movups %xmm1, 0x80010(%rax,%rcx)
movups 0x80020(%rdi), %xmm1
movups %xmm1, 0x80020(%rax,%rcx)
movups 0x80030(%rdi), %xmm1
movups %xmm1, 0x80030(%rax,%rcx)
movups 0x80040(%rdi), %xmm1
movups %xmm1, 0x80040(%rax,%rcx)
movq 0x74e8(%rip), %rax      # 0xf290
movb $0x1, (%rax,%rsi)
movsd 0x329c(%rip), %xmm1     # 0xb050
divsd %xmm0, %xmm1
movq 0x74c9(%rip), %rax      # 0xf288
movsd %xmm1, (%rax,%rsi,8)
incq 0x74d5(%rip)            # 0xf2a0
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
subq $0xf0, %rsp
movaps 0x38e4(%rip), %xmm0     # 0xb6d0
movq %rsp, %rax
movaps %xmm0, 0x20(%rax)
movaps 0x38c6(%rip), %xmm0     # 0xb6c0
movaps %xmm0, 0x10(%rax)
movaps 0x38ab(%rip), %xmm0     # 0xb6b0
movaps %xmm0, (%rax)
leaq 0x6ec1(%rip), %rsi      # 0xecd0
leaq 0x90(%rsp), %r8
movl $0xc, %ecx
movq %r8, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x30(%rsp), %rdx
movq $0x0, (%rdx)
movq $0x40000, 0x8(%rdx)     # imm = 0x40000
movq $0x80000, 0x10(%rdx)    # imm = 0x80000
movq $0x80008, 0x18(%rdx)    # imm = 0x80008
movq $0x80010, 0x20(%rdx)    # imm = 0x80010
movq $0x80018, 0x28(%rdx)    # imm = 0x80018
movq $0x80020, 0x30(%rdx)    # imm = 0x80020
movq $0x80028, 0x38(%rdx)    # imm = 0x80028
movq $0x80030, 0x40(%rdx)    # imm = 0x80030
movq $0x80038, 0x48(%rdx)    # imm = 0x80038
movq $0x80040, 0x50(%rdx)    # imm = 0x80040
movq $0x80048, 0x58(%rdx)    # imm = 0x80048
leaq 0x73e3(%rip), %rbx      # 0xf270
movl $0xc, %edi
movq %rax, %rsi
movq %r8, %rcx
movq %rbx, %r8
callq 0x2200
movq %rbx, %rdi
callq 0x2270
addq $0xf0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
subq $0x80, %rsp
movaps 0x3820(%rip), %xmm0     # 0xb6e0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movabsq $0x100008000, %rax      # imm = 0x100008000
movq %rax, 0x10(%rsi)
movaps 0x6e75(%rip), %xmm0     # 0xed50
leaq 0x50(%rsp), %rcx
movaps %xmm0, 0x20(%rcx)
movaps 0x6e55(%rip), %xmm0     # 0xed40
movaps %xmm0, 0x10(%rcx)
movaps 0x6e3a(%rip), %xmm0     # 0xed30
movaps %xmm0, (%rcx)
leaq 0x20(%rsp), %rdx
movq $0x0, (%rdx)
movq $0x40000, 0x8(%rdx)     # imm = 0x40000
movq $0x80000, 0x10(%rdx)    # imm = 0x80000
movq $0xc0000, 0x18(%rdx)    # imm = 0xC0000
movq $0x100000, 0x20(%rdx)   # imm = 0x100000
movq $0x140000, 0x28(%rdx)   # imm = 0x140000
leaq 0x7344(%rip), %rbx      # 0xf278
movl $0x6, %edi
movq %rbx, %r8
callq 0x2200
movq %rbx, %rdi
callq 0x2270
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq %rdi, 0x733b(%rip)      # 0xf298
movq $0x0, 0x7338(%rip) # 0xf2a0
movl $0x80050, %esi          # imm = 0x80050
callq 0x2110
movq %rax, 0x7307(%rip)      # 0xf280
testq %rax, %rax
je 0x7f9e
movq %rbx, %rdi
callq 0xa795
movq %rax, 0x7303(%rip)      # 0xf290
movq %rbx, %rdi
callq 0xa731
movq %rax, 0x72ec(%rip)      # 0xf288
popq %rbx
retq
movq 0x7023(%rip), %rdi      # 0xefc8
leaq 0x32b4(%rip), %rsi      # 0xb260
callq 0x21e0
movl $0x1, %edi
callq 0x2260
// File: /workspace/github_c_makefile_star2_O3/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 0x72d6(%rip), %rcx      # 0xf298
testq %rcx, %rcx
jle 0x8009
movq 0x72c2(%rip), %rdx      # 0xf290
movq $-0x1, %rax
xorpd %xmm0, %xmm0
movq 0x72a8(%rip), %rsi      # 0xf288
xorl %edi, %edi
cmpb $0x1, (%rdx,%rdi)
jne 0x8000
movsd (%rsi,%rdi,8), %xmm1
cmpq $-0x1, %rax
je 0x7ff9
ucomisd %xmm0, %xmm1
jbe 0x8000
movq %rdi, %rax
movapd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rcx
jne 0x7fe2
retq
movq $-0x1, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
movq 0x727f(%rip), %rcx      # 0xf298
testq %rcx, %rcx
jle 0x8035
movq 0x726b(%rip), %rdx      # 0xf290
xorl %eax, %eax
cmpb $0x0, (%rdx,%rax)
je 0x8054
incq %rax
cmpq %rax, %rcx
jne 0x8027
movq 0x6f8c(%rip), %rdi      # 0xefc8
leaq 0x3648(%rip), %rsi      # 0xb68b
movl $0x19, %edx
callq 0x2210
movq $-0x1, %rax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
leaq 0x3698(%rip), %rsi      # 0xb6f8
callq 0x2240
movq %rax, %rbx
testq %rax, %rax
je 0x8075
movq %rbx, %rdi
callq 0x21f0
testq %rbx, %rbx
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x364a(%rip), %rsi      # 0xb701
movq %rax, %rdi
callq 0x2240
movq %rax, %r14
leaq 0x363a(%rip), %rsi      # 0xb703
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x22d0
movq %r14, %rdi
callq 0x2230
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21f0
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x3600(%rip), %rsi      # 0xb6f8
callq 0x2240
movq %rax, %rbx
movq %rax, %rdi
callq 0x2310
xorl %r14d, %r14d
testl %eax, %eax
jne 0x812c
movq %rbx, %rdi
callq 0x2320
xorl %ecx, %ecx
cmpl $0xa, %eax
sete %cl
addq %rcx, %r14
movq %rbx, %rdi
callq 0x2310
jmp 0x810b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
movsd (%rdi), %xmm1
testq %rsi, %rsi
jle 0x81a3
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm0
maxsd %xmm1, %xmm0
incq %rax
movapd %xmm0, %xmm1
cmpq %rax, %rsi
jne 0x818d
retq
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movsd (%rdi), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x8257
movq %rdi, %r14
movsd 0x3268(%rip), %xmm1     # 0xb458
callq 0x2390
mulsd 0x350b(%rip), %xmm0     # 0xb708
movsd %xmm0, (%rsp)
movsd 0x10(%r14), %xmm0
movsd 0x2e40(%rip), %xmm1     # 0xb050
addsd %xmm0, %xmm1
divsd %xmm1, %xmm0
movsd 0x31c8(%rip), %xmm1     # 0xb3e8
callq 0x2390
movapd %xmm0, %xmm2
mulsd (%rsp), %xmm2
movsd 0x18(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x8244
sqrtsd %xmm0, %xmm0
jmp 0x8253
movsd %xmm2, (%rsp)
callq 0x2160
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, (%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
cmpl $-0x1, %edx
je 0x8761
cmpl $0x1, %ebx
jne 0x87ba
movslq %ebp, %rdi
shlq $0x4, %rdi
callq 0x2280
testq %rax, %rax
je 0x879b
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
movl $0x1, %ecx
movq %rax, %r8
callq 0x8274
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2250
leaq 0x3036(%rip), %rdi      # 0xb7d8
leaq 0x2f7a(%rip), %rsi      # 0xb723
leaq 0x300a(%rip), %rcx      # 0xb7ba
movl $0xbd, %edx
callq 0x2100
leaq 0x2fe1(%rip), %rdi      # 0xb7a2
leaq 0x2f5b(%rip), %rsi      # 0xb723
leaq 0x2feb(%rip), %rcx      # 0xb7ba
movl $0xbb, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, 0x8(%rsp)
cmpl $-0x1, %ecx
je 0x87fe
cmpl $0x1, %ecx
jne 0x88a7
movl %ecx, %r14d
movslq %ebx, %r12
movq %r12, %rdi
shlq $0x4, %rdi
movq %rdi, %r15
callq 0x2280
testq %rax, %rax
je 0x8888
movl %ebx, 0x4(%rsp)
imull %ebx, %ebp
movl %ebp, (%rsp)
testl %ebp, %ebp
jle 0x885e
movl (%rsp), %edx
movq %rdx, 0x10(%rsp)
xorl %ebp, %ebp
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl %r12d, %esi
movl %r14d, %edx
movl $0x1, %ecx
movq %rax, %r13
movq %rax, %r8
callq 0x8274
movq %r13, %rax
addq %r12, %rbp
addq %r15, %rbx
cmpq 0x10(%rsp), %rbp
jl 0x8835
movq %rax, %rdi
callq 0x2250
movq 0x8(%rsp), %rdi
movl (%rsp), %esi
movl %r14d, %edx
movl 0x4(%rsp), %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x84b8
leaq 0x2f49(%rip), %rdi      # 0xb7d8
leaq 0x2e8d(%rip), %rsi      # 0xb723
leaq 0x2f45(%rip), %rcx      # 0xb7e2
movl $0xd5, %edx
callq 0x2100
leaq 0x2ef4(%rip), %rdi      # 0xb7a2
leaq 0x2e6e(%rip), %rsi      # 0xb723
leaq 0x2f26(%rip), %rcx      # 0xb7e2
movl $0xd2, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, 0x10(%rsp)
cmpl $-0x1, %r8d
je 0x88ef
cmpl $0x1, %r8d
jne 0x8a0f
movl %r8d, %r12d
movl %ecx, 0xc(%rsp)
imull %ecx, %r15d
movslq %r15d, %rax
movq %rax, 0x28(%rsp)
movq %rax, %rdi
shlq $0x4, %rdi
movq %rdi, 0x20(%rsp)
callq 0x2280
testq %rax, %rax
je 0x89f0
imull %r15d, %r14d
movl %r14d, 0x8(%rsp)
testl %r14d, %r14d
movl 0xc(%rsp), %ecx
jle 0x89c6
movl %r15d, 0x1c(%rsp)
movslq %ecx, %r14
movl 0x8(%rsp), %ecx
movq %r14, %rdx
shlq $0x4, %rdx
movq %rdx, 0x30(%rsp)
xorl %ebx, %ebx
movl %r12d, %r15d
movq 0x10(%rsp), %r12
movq %r12, %rdi
movl %r14d, %esi
movl %r15d, %edx
movq %rcx, %r13
movl $0x1, %ecx
movq %rax, %rbp
movq %rax, %r8
callq 0x8274
movq %r13, %rcx
movq %rbp, %rax
addq %r14, %rbx
addq 0x30(%rsp), %r12
cmpq %r13, %rbx
jl 0x8954
cmpl $0x0, 0x8(%rsp)
movl %r15d, %r12d
movl 0x1c(%rsp), %r15d
jle 0x89c6
xorl %ebx, %ebx
movq 0x10(%rsp), %r14
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl 0xc(%rsp), %ecx
movq %rbp, %r8
callq 0x8274
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbp, %rax
addq %rdx, %rbx
addq %rsi, %r14
cmpq %r13, %rbx
jl 0x8999
movq %rax, %rdi
callq 0x2250
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
movl %r12d, %edx
movl %r15d, %ecx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x84b8
leaq 0x2de1(%rip), %rdi      # 0xb7d8
leaq 0x2d25(%rip), %rsi      # 0xb723
leaq 0x2e02(%rip), %rcx      # 0xb807
movl $0xe7, %edx
callq 0x2100
leaq 0x2d8c(%rip), %rdi      # 0xb7a2
leaq 0x2d06(%rip), %rsi      # 0xb723
leaq 0x2de3(%rip), %rcx      # 0xb807
movl $0xe3, %edx
callq 0x2100
nop
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
cmpl $0x0, 0x646c(%rip)      # 0xf2b8
je 0x8e68
movsd 0x6452(%rip), %xmm0     # 0xf2a8
movsd %xmm0, (%rsp)
movsd 0x644d(%rip), %xmm0     # 0xf2b0
jmp 0x8ef5
callq 0x2090
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd 0x2a3c(%rip), %xmm0     # 0xb8b8
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x2090
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd 0x2a1f(%rip), %xmm1     # 0xb8b8
movsd (%rsp), %xmm2
addsd %xmm2, %xmm2
movsd 0x21ae(%rip), %xmm0     # 0xb058
addsd %xmm0, %xmm2
addsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x63ea(%rip)     # 0xf2a8
mulsd %xmm1, %xmm1
movsd %xmm2, (%rsp)
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x63d5(%rip)     # 0xf2b0
ucomisd 0x216d(%rip), %xmm0     # 0xb050
jae 0x8e68
ucomisd 0x2593(%rip), %xmm0     # 0xb480
jne 0x8ef5
jnp 0x8e68
callq 0x2170
mulsd 0x29be(%rip), %xmm0     # 0xb8c0
divsd 0x63a6(%rip), %xmm0     # 0xf2b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x8f1a
sqrtsd %xmm0, %xmm0
jmp 0x8f1f
callq 0x2160
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movl $0x1, %eax
subl 0x6385(%rip), %eax      # 0xf2b8
movl %eax, 0x637f(%rip)      # 0xf2b8
movapd %xmm1, %xmm0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x2380
leaq 0x1e3a(%rip), %rdi      # 0xb0f3
leaq 0x1dd8(%rip), %rsi      # 0xb098
leaq 0x200(%rsp), %rdx
callq 0x807d
movq %rsp, %rdi
leaq 0x200(%rsp), %rsi
movl $0x10, %edx
callq 0x2040
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x21c0
leaq 0x1f45(%rip), %rsi      # 0xb239
movl $0x1, %edx
movq %rax, %rdi
callq 0x2210
movq %rsp, %rdi
callq 0x2120
movq %rsp, %rdi
callq 0x22c0
movq 0x5c90(%rip), %rax      # 0xefa8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x2190
leaq 0xf8(%rsp), %rdi
callq 0x20a0
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x22e0
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdi, %r14
leaq 0x1d7d(%rip), %rdi      # 0xb0f3
leaq 0x1d1b(%rip), %rsi      # 0xb098
leaq 0x70(%rsp), %rbx
movq %rbx, %rdx
callq 0x807d
leaq 0x2367(%rip), %rsi      # 0xb6f8
movq %rbx, %rdi
callq 0x2240
movq %rax, %r15
movq %rsp, %r12
movq %r12, %rdi
movl $0x64, %esi
movq %rax, %rdx
callq 0x2330
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2290
movq %rax, (%r14)
movq %r15, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x23d0
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movl $0x8, %esi
callq 0x2110
movq %rax, %rbx
testq %rax, %rax
jne 0xa691
movq 0x4973(%rip), %r14      # 0xefc8
leaq 0x12a4(%rip), %rsi      # 0xb900
movl $0x22, %edx
movq %r14, %rdi
callq 0x2210
leaq 0x12b3(%rip), %rsi      # 0xb923
movl $0xb, %edx
movq %r14, %rdi
callq 0x2210
leaq 0x12ab(%rip), %rsi      # 0xb92f
movl $0xb, %edx
movq %r14, %rdi
callq 0x2210
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x8, %esi
callq 0x2110
movq %rax, %rbx
testq %r14, %r14
jle 0xa6df
xorl %r12d, %r12d
movl $0x8, %esi
movq %r15, %rdi
callq 0x2110
movq %rax, (%rbx,%r12,8)
incq %r12
cmpq %r12, %r14
jne 0xa6bf
cmpq $0x0, (%rbx,%r14,8)
jne 0xa722
movq 0x48e2(%rip), %r14      # 0xefc8
leaq 0x1213(%rip), %rsi      # 0xb900
movl $0x22, %edx
movq %r14, %rdi
callq 0x2210
leaq 0x123a(%rip), %rsi      # 0xb93b
movl $0xb, %edx
movq %r14, %rdi
callq 0x2210
leaq 0x121a(%rip), %rsi      # 0xb92f
movl $0xb, %edx
movq %r14, %rdi
callq 0x2210
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movl $0x8, %esi
callq 0x2110
movq %rax, %rbx
testq %rax, %rax
jne 0xa78a
movq 0x487a(%rip), %r14      # 0xefc8
leaq 0x11ab(%rip), %rsi      # 0xb900
movl $0x22, %edx
movq %r14, %rdi
callq 0x2210
leaq 0x11de(%rip), %rsi      # 0xb947
movl $0xd, %edx
movq %r14, %rdi
callq 0x2210
leaq 0x11b2(%rip), %rsi      # 0xb92f
movl $0xb, %edx
movq %r14, %rdi
callq 0x2210
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movl $0x1, %esi
callq 0x2110
movq %rax, %rbx
testq %rax, %rax
jne 0xa7ee
movq 0x4816(%rip), %r14      # 0xefc8
leaq 0x1147(%rip), %rsi      # 0xb900
movl $0x22, %edx
movq %r14, %rdi
callq 0x2210
leaq 0x1188(%rip), %rsi      # 0xb955
movl $0xb, %edx
movq %r14, %rdi
callq 0x2210
leaq 0x114e(%rip), %rsi      # 0xb92f
movl $0xb, %edx
movq %r14, %rdi
callq 0x2210
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x8, %esi
callq 0x2110
movq %rax, %rbx
testq %r14, %r14
jle 0xa83c
xorl %r12d, %r12d
movl $0x8, %esi
movq %r15, %rdi
callq 0x2110
movq %rax, (%rbx,%r12,8)
incq %r12
cmpq %r12, %r14
jne 0xa81c
cmpq $0x0, (%rbx,%r14,8)
jne 0xa87f
movq 0x4785(%rip), %r14      # 0xefc8
leaq 0x10b6(%rip), %rsi      # 0xb900
movl $0x22, %edx
movq %r14, %rdi
callq 0x2210
leaq 0x1103(%rip), %rsi      # 0xb961
movl $0xd, %edx
movq %r14, %rdi
callq 0x2210
leaq 0x10bd(%rip), %rsi      # 0xb92f
movl $0xb, %edx
movq %r14, %rdi
callq 0x2210
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x8, %esi
callq 0x2110
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
testq %r15, %r15
jle 0xa956
xorl %r15d, %r15d
movq 0x46fc(%rip), %r13      # 0xefc8
movl $0x8, %esi
movq %r14, %rdi
callq 0x2110
movq %rax, %rbp
movq 0x8(%rsp), %rax
movq %rbp, (%rax,%r15,8)
testq %r14, %r14
jle 0xa948
xorl %r12d, %r12d
movl $0x8, %esi
movq %rbx, %rdi
callq 0x2110
movq %rax, (%rbp,%r12,8)
testq %rax, %rax
jne 0xa940
movl $0x22, %edx
movq %r13, %rdi
leaq 0xfed(%rip), %rsi       # 0xb900
callq 0x2210
movl $0xf, %edx
movq %r13, %rdi
leaq 0x1048(%rip), %rsi      # 0xb96f
callq 0x2210
movl $0xb, %edx
movq %r13, %rdi
leaq 0xff4(%rip), %rsi       # 0xb92f
callq 0x2210
incq %r12
cmpq %r12, %r14
jne 0xa8ed
incq %r15
cmpq 0x10(%rsp), %r15
jne 0xa8cc
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
jle 0xa98e
movq %rsi, %r14
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2250
incq %r15
cmpq %r15, %r14
jne 0xa97d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2250
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
jle 0xa9bf
movq %rsi, %r14
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2250
incq %r15
cmpq %r15, %r14
jne 0xa9ae
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2250
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rsi, %rsi
jle 0xaa1d
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testq %rbx, %rbx
jle 0xaa03
xorl %r13d, %r13d
movq (%r15,%r12,8), %rax
movq (%rax,%r13,8), %rdi
callq 0x2250
incq %r13
cmpq %r13, %rbx
jne 0xa9ee
movq (%r15,%r12,8), %rdi
callq 0x2250
incq %r12
cmpq %r14, %r12
jne 0xa9e6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rsi, %rsi
jle 0xaab8
leaq 0x1(%rsi), %rax
andq $-0x2, %rax
decq %rsi
movq %rsi, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
movdqa 0xa4c(%rip), %xmm2      # 0xb490
xorl %ecx, %ecx
movdqa 0xea2(%rip), %xmm3      # 0xb8f0
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
movdqa 0xa72(%rip), %xmm5      # 0xb4d0
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm1, %xmm7
pcmpeqd %xmm1, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edx
notl %edx
testb $0x1, %dl
je 0xaa97
movsd %xmm0, (%rdi,%rcx,8)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edx
testb $0x1, %dl
je 0xaaab
movsd %xmm0, 0x8(%rdi,%rcx,8)
addq $0x2, %rcx
paddq %xmm5, %xmm2
cmpq %rcx, %rax
jne 0xaa5e
retq
// File: /workspace/github_c_makefile_star2_O3/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: matrix_const_add(double**, double**, double, long, long)
void matrix_const_add( double** res, double** M, double a, long n, long m )
{
 	   long i,j;	     
 	   for(i=0;i<n;i++){
                      for(j=0;j<m;j++){
	   							         res[i][j]=M[i][j]+a;
                                         }
                    }	   
 	   
	   return;
	   }

// Assembly:
testq %rdx, %rdx
jle 0xab6b
xorl %eax, %eax
testq %rcx, %rcx
jle 0xab63
movq (%rsi,%rax,8), %r8
movq (%rdi,%rax,8), %r9
xorl %r10d, %r10d
movsd (%r8,%r10,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r9,%r10,8)
incq %r10
cmpq %r10, %rcx
jne 0xab4b
incq %rax
cmpq %rdx, %rax
jne 0xab3b
retq
// File: /workspace/github_c_makefile_star2_O3/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: matrix_add(double**, double**, double**, long, long)
void matrix_add( double** res, double** M1, double** M2, long n, long m )
{
 	   long i,j;	     
 	   for(i=0;i<n;i++){
                      for(j=0;j<m;j++){
	   							         res[i][j]=M1[i][j]+M2[i][j];
                                         }
                    }	   
 	   
	   return;
	   }

// Assembly:
testq %rcx, %rcx
jle 0xabaa
pushq %rbx
xorl %eax, %eax
testq %r8, %r8
jle 0xaba1
movq (%rsi,%rax,8), %r9
movq (%rdx,%rax,8), %r10
movq (%rdi,%rax,8), %r11
xorl %ebx, %ebx
movsd (%r9,%rbx,8), %xmm0
addsd (%r10,%rbx,8), %xmm0
movsd %xmm0, (%r11,%rbx,8)
incq %rbx
cmpq %rbx, %r8
jne 0xab87
incq %rax
cmpq %rcx, %rax
jne 0xab74
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: matrix_const_multiply(double**, double**, double, long, long)
void matrix_const_multiply( double** res, double** M, double factor, long n, long m)
{
 	 //multiplies matrix with constant
 	   long i,j;	     
 	   for(i=0;i<n;i++){
                      for(j=0;j<m;j++){
                                       res[i][j]=M[i][j]*factor;
                                       }
 	   
	   }
	   return;
	   }

// Assembly:
testq %rdx, %rdx
jle 0xabe2
xorl %eax, %eax
testq %rcx, %rcx
jle 0xabda
movq (%rsi,%rax,8), %r8
movq (%rdi,%rax,8), %r9
xorl %r10d, %r10d
movsd (%r8,%r10,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%r9,%r10,8)
incq %r10
cmpq %r10, %rcx
jne 0xabc2
incq %rax
cmpq %rdx, %rax
jne 0xabb2
retq
// File: /workspace/github_c_makefile_star2_O3/guszejnovdavid[P]MISFIT/vectorfunctions.c
// Function: matrix_matrix_multiply(double**, double**, double**, long, long)
void matrix_matrix_multiply(  double** res, double** M1, double** M2, long n, long m )
{
 	 //multiplies array with constant
 	   long i,j;	     
 	   for(i=0;i<n;i++){
                               for(j=0;j<m;j++){
	   							                                       res[i][j]=M1[i][j]*M2[i][j];	   
                                                         }
 	   
	   }
	   return;
	   }

// Assembly:
testq %rcx, %rcx
jle 0xac21
pushq %rbx
xorl %eax, %eax
testq %r8, %r8
jle 0xac18
movq (%rsi,%rax,8), %r9
movq (%rdx,%rax,8), %r10
movq (%rdi,%rax,8), %r11
xorl %ebx, %ebx
movsd (%r9,%rbx,8), %xmm0
mulsd (%r10,%rbx,8), %xmm0
movsd %xmm0, (%r11,%rbx,8)
incq %rbx
cmpq %rbx, %r8
jne 0xabfe
incq %rax
cmpq %rcx, %rax
jne 0xabeb
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/LuaJIT[P]LuaJIT/src/./../dynasm/dasm_x86.h
// Function: dasm_init
void dasm_init(Dst_DECL, int maxsection)
{
  dasm_State *D;
  size_t psz = 0;
  Dst_REF = NULL;
  DASM_M_GROW(Dst, struct dasm_State, Dst_REF, psz, DASM_PSZ(maxsection));
  D = Dst_REF;
  D->psize = psz;
  D->lglabels = NULL;
  D->lgsize = 0;
  D->pclabels = NULL;
  D->pcsize = 0;
  D->globals = NULL;
  D->maxsection = maxsection;
  memset((void *)D->sections, 0, maxsection * sizeof(dasm_Section));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq $0x0, (%rdi)
leal -0x1(%rbx), %eax
cltq
leaq (%rax,%rax,4), %rax
leaq 0x78(,%rax,8), %rax
movl $0x10, %ecx
movq %rcx, %r15
addq %rcx, %rcx
cmpq %rax, %r15
jb 0x57e3
movq %r15, %rdi
callq 0x5150
movq %rax, (%r14)
testq %rax, %rax
je 0x5835
movq %r15, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
movl %ebx, 0x48(%rax)
addq $0x50, %rax
movslq %ebx, %rcx
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rdx
movq %rax, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x50c0
movl $0x1, %edi
callq 0x51c0
// File: /workspace/github_c_makefile_star2_O3/LuaJIT[P]LuaJIT/src/host/buildvm.c
// Function: sym_decorate
static const char *sym_decorate(BuildCtx *ctx,
				const char *prefix, const char *suffix)
{
  char name[256];
  char *p;
#if LJ_64
  const char *symprefix = ctx->mode == BUILD_machasm ? "_" : "";
#elif LJ_TARGET_XBOX360
  const char *symprefix = "";
#else
  const char *symprefix = ctx->mode != BUILD_elfasm ? "_" : "";
#endif
  sprintf(name, "%s%s%s", symprefix, prefix, suffix);
  p = strchr(name, '@');
  if (p) {
#if LJ_TARGET_X86ORX64
    if (!LJ_64 && (ctx->mode == BUILD_coffasm || ctx->mode == BUILD_peobj))
      name[0] = name[1] == 'R' ? '_' : '@';  /* Just for _RtlUnwind@16. */
    else
      *p = '\0';
#elif LJ_TARGET_PPC && !LJ_TARGET_CONSOLE
    /* Keep @plt etc. */
#else
    *p = '\0';
#endif
  }
  p = (char *)malloc(strlen(name)+1);  /* MSVC doesn't like strdup. */
  strcpy(p, name);
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r8
movq %rsi, %rcx
cmpl $0x2, %edi
leaq 0xb9b5(%rip), %rax      # 0x12d93
leaq 0xb01a(%rip), %rdx      # 0x123ff
cmoveq %rax, %rdx
leaq 0x9993(%rip), %rsi      # 0x10d83
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x51b0
movq %rbx, %rdi
movl $0x40, %esi
callq 0x50b0
testq %rax, %rax
je 0x7412
movb $0x0, (%rax)
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x50a0
leaq 0x1(%rax), %rdi
callq 0x5150
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5060
movq %r14, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/LuaJIT[P]LuaJIT/src/host/buildvm_lib.c
// Function: libdef_lua
static void libdef_lua(BuildCtx *ctx, char *p, int arg)
{
  UNUSED(arg);
  if (ctx->mode == BUILD_libdef) {
    int i;
    for (i = 0; libbc_map[i].name != NULL; i++) {
      if (!strcmp(libbc_map[i].name, p)) {
	int ofs = libbc_map[i].ofs;
	int len = libbc_map[i+1].ofs - ofs;
	obuf[2]++;  /* Bump hash table size. */
	*optr++ = LIBINIT_LUA;
	libdef_name(p, 0);
	memcpy(optr, libbc_code + ofs, len);
	libdef_fixupbc(optr);
	optr += len;
	return;
      }
    }
    fprintf(stderr, "Error: missing libbc definition for %s\n", p);
    exit(1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x7, 0x8(%rdi)
jne 0xa815
movq %rsi, %r14
leaq 0x89a4(%rip), %rdi      # 0x1306d
callq 0x5110
leaq 0xc67b(%rip), %rbx      # 0x16d50
movl $0x1, %r15d
testl %eax, %eax
je 0xa70a
leaq 0xc66a(%rip), %r12      # 0x16d50
cmpq $0x8, %r15
je 0xa821
movq 0x10(%r12), %rdi
addq $0x10, %r12
movq %r14, %rsi
callq 0x5110
incq %r15
testl %eax, %eax
jne 0xa6e6
jmp 0xa70d
movq %rbx, %r12
movslq 0x8(%r12), %r12
shlq $0x4, %r15
movslq 0x8(%r15,%rbx), %rbx
subq %r12, %rbx
incb 0xcb0e(%rip)            # 0x17232
movq 0xeb05(%rip), %rax      # 0x19230
leaq 0x1(%rax), %rcx
movq %rcx, 0xeafa(%rip)      # 0x19230
movb $-0x7, (%rax)
movq %r14, %rdi
xorl %esi, %esi
callq 0xab45
movq 0xeae6(%rip), %r14      # 0x19230
leaq 0x83bf(%rip), %rsi      # 0x12b10
addq %r12, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5140
leaq 0x5(%r14), %rax
cmpb $0x0, 0x4(%r14)
js 0xa76f
movq %rax, %rdx
jmp 0xa77b
leaq 0x1(%rax), %rdx
cmpb $0x0, (%rax)
movq %rdx, %rax
js 0xa76f
leaq 0x1(%rdx), %rcx
cmpb $0x0, (%rdx)
js 0xa789
movq %rcx, %rax
jmp 0xa795
leaq 0x1(%rcx), %rax
cmpb $0x0, (%rcx)
movq %rax, %rcx
js 0xa789
movzbl (%rax), %edx
incq %rax
testb %dl, %dl
jns 0xa7be
andl $0x7f, %edx
movl $0x7, %ecx
movzbl (%rax), %esi
movl %esi, %edi
andl $0x7f, %edi
shll %cl, %edi
orl %edi, %edx
incq %rax
addl $0x7, %ecx
testb %sil, %sil
js 0xa7a7
testl %edx, %edx
je 0xa80b
movl %edx, %ecx
xorl %edx, %edx
movl $0x11, %esi
movl $0xf, %edi
movzbl (%rax,%rdx,4), %r8d
movb 0x2(%rax,%rdx,4), %r9b
movl %r8d, %r10d
xorb $0x10, %r10b
movzbl %r9b, %r11d
xorb $0xe, %r9b
orb %r10b, %r9b
cmovel %esi, %r8d
cmovel %edi, %r11d
movb %r8b, (%rax,%rdx,4)
movb %r11b, 0x2(%rax,%rdx,4)
incq %rdx
cmpl %edx, %ecx
jne 0xa7d0
movq 0xea25(%rip), %r14      # 0x19230
addq %rbx, %r14
movq %r14, 0xea1b(%rip)      # 0x19230
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x5456
// File: /workspace/github_c_makefile_star2_O3/ngkaho1234[P]ext4-extents-tree/exttraverse.c
// Function: free_ext4_db
static void free_ext4_db(struct inode *inode)
{
	struct db_handle *db_handle = inode->i_db;
	struct block_device *bdev = inode->i_sb->s_bdev;

	inode_free(inode);
	db_close(db_handle);
	bdev_free(bdev);
	fs_bh_showstat();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%rdi), %rax
movq 0x18(%rdi), %r14
movq 0x10(%rax), %rbx
testb $0x1, 0x74(%rdi)
je 0x2751
movq 0x78(%r15), %rax
testq %rax, %rax
je 0x2751
movq %r15, %rdi
callq *%rax
movq %r15, %rdi
callq 0x2030
movq %r14, %rdi
callq 0x4240
movq %rbx, %rdi
callq 0x2a57
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2870
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: accept_start
static int
accept_start(struct dispatch_state * dstate)
{
	struct sock_listen * L;
	size_t i;

	/* Make sure we don't have any in-progress accepts. */
	for (i = 0; i < dstate->nsock_listen; i++) {
		L = &dstate->sock_listen[i];
		if (L->accept_cookie != NULL) {
			warn0("Already trying to accept a connection!");
			goto err0;
		}
	}

	/* Try to accept connections. */
	for (i = 0; i < dstate->nsock_listen; i++) {
		L = &dstate->sock_listen[i];
		if ((L->accept_cookie =
		    network_accept(L->s, callback_gotconn, L)) == NULL)
			goto err1;
	}

	/* Success! */
	return (0);

err1:
	/* Cancel the accepts we started. */
	accept_stop(dstate);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x3429
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
addq $0x10, %rcx
cmpq $0x0, (%rcx)
jne 0x342c
addq $0x18, %rcx
decq %rax
jne 0x33de
xorl %r15d, %r15d
leaq 0x104(%rip), %r14       # 0x34fb
xorl %r12d, %r12d
movq (%rbx), %r13
leaq (%r15,%r13), %rdx
movl 0x8(%r13,%r15), %edi
movq %r14, %rsi
callq 0x5e68
movq %rax, 0x10(%r13,%r15)
testq %rax, %rax
je 0x3447
incq %r12
addq $0x18, %r15
cmpq 0x8(%rbx), %r12
jb 0x33fa
xorl %eax, %eax
jmp 0x3454
xorl %eax, %eax
retq
leaq 0x7e8a(%rip), %rdi      # 0xb2bd
xorl %eax, %eax
callq 0x8b1f
callq 0x20a0
movl $0x0, (%rax)
jmp 0x344f
movq %rbx, %rdi
callq 0x36da
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: dispatch_done
void
dispatch_done(struct dispatch_state * dstate)
{

	/* Sanity-check. */
	assert(dstate->failed == 1);
	assert(dstate->sock_active == NULL);
	assert(dstate->nsock_active == 0);

	/* Free memory. */
	free(dstate->sock_listen);
	free(dstate);
}

// Assembly:
pushq %rbx
cmpl $0x1, 0x30(%rdi)
jne 0x349e
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
jne 0x34bd
cmpq $0x0, 0x18(%rbx)
jne 0x34dc
movq (%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
leaq 0x7d97(%rip), %rdi      # 0xb23c
leaq 0x7da4(%rip), %rsi      # 0xb250
leaq 0x7da8(%rip), %rcx      # 0xb25b
movl $0x20e, %edx            # imm = 0x20E
callq 0x21a0
leaq 0x7dc3(%rip), %rdi      # 0xb287
leaq 0x7d85(%rip), %rsi      # 0xb250
leaq 0x7d89(%rip), %rcx      # 0xb25b
movl $0x20f, %edx            # imm = 0x20F
callq 0x21a0
leaq 0x7dc0(%rip), %rdi      # 0xb2a3
leaq 0x7d66(%rip), %rsi      # 0xb250
leaq 0x7d6a(%rip), %rcx      # 0xb25b
movl $0x210, %edx            # imm = 0x210
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: accept_stop
static void
accept_stop(struct dispatch_state * dstate)
{
	struct sock_listen * L;
	size_t i;

	/* Iterate through the sockets, cancelling any accepts. */
	for (i = 0; i < dstate->nsock_listen; i++) {
		L = &dstate->sock_listen[i];
		if (L->accept_cookie != NULL) {
			network_accept_cancel(L->accept_cookie);
			L->accept_cookie = NULL;
		}
	}
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x372b
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %r14d
xorl %r15d, %r15d
movq (%rbx), %r12
movq (%r12,%r14), %rdi
testq %rdi, %rdi
je 0x3714
callq 0x5f26
movq $0x0, (%r12,%r14)
movq 0x8(%rbx), %rax
incq %r15
addq $0x18, %r14
cmpq %rax, %r15
jb 0x36f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/mux/dispatch.c
// Function: readreq
static int
readreq(struct sock_active * S)
{

	/* We shouldn't be waiting yet. */
	assert(S->read_cookie == NULL);

	/* Wait for request packets to arrive. */
	if ((S->read_cookie =
	    wire_readpacket_wait(S->readq, callback_gotrequests, S)) == NULL) {
		warnp("Error waiting for requests to arrive");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x30(%rdi)
jne 0x3790
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq 0x6d(%rip), %rsi        # 0x37af
movq %rbx, %rdx
callq 0x8d72
movq %rax, %rcx
movq %rax, 0x30(%rbx)
xorl %eax, %eax
testq %rcx, %rcx
jne 0x378e
callq 0x20a0
cmpl $0x0, (%rax)
je 0x377b
movq %rax, %rbx
leaq 0x7c31(%rip), %rdi      # 0xb39d
xorl %eax, %eax
callq 0x8a00
movl $0x0, (%rbx)
jmp 0x3789
leaq 0x7c1b(%rip), %rdi      # 0xb39d
xorl %eax, %eax
callq 0x8b1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
leaq 0x7bcd(%rip), %rdi      # 0xb364
leaq 0x7ab2(%rip), %rsi      # 0xb250
leaq 0x7bd6(%rip), %rcx      # 0xb37b
movl $0xd5, %edx
callq 0x21a0