LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: GcreateRoot(GhdrNd*)
GHdrNd GcreateRoot(GHdrNd hdrNdTree)
{  
    GHdrNd hdrNdRoot = GinitHdrNd();
    double* iBottomLeft = (double*)calloc(DIMENSION, sizeof(double));
    // assert(iBottomLeft != NULL);

	double* iTopRight = (double*)calloc(DIMENSION,sizeof(double));
	// assert(iTopRight != NULL);

	GLstNd lstNdTemp = hdrNdTree->ptrFirstNd;
	int iCnt = 0;
	Boolean bIsFirst = TRUE;

	while(lstNdTemp != NULL)
    {	
    	for(iCnt = 0; iCnt < DIMENSION; iCnt++)
        {   
        	if(bIsFirst)
            {   
            	iBottomLeft[iCnt] = lstNdTemp->tnInfo->tdInfo->rgnRect->iBottomLeft[iCnt];
				iTopRight[iCnt] = lstNdTemp->tnInfo->tdInfo->rgnRect->iTopRight[iCnt];
         	}
			else
            {   
            	if(lstNdTemp->tnInfo->tdInfo->rgnRect->iBottomLeft[iCnt] < iBottomLeft[iCnt])
					iBottomLeft[iCnt] = lstNdTemp->tnInfo->tdInfo->rgnRect->iBottomLeft[iCnt];

				if(lstNdTemp->tnInfo->tdInfo->rgnRect->iTopRight[iCnt] > iTopRight[iCnt])
					iTopRight[iCnt] = lstNdTemp->tnInfo->tdInfo->rgnRect->iTopRight[iCnt];
    	    }
		}
		lstNdTemp = lstNdTemp->ptrNextNd;
		bIsFirst = FALSE;
	}

	hdrNdRoot->ptrFirstNd = GinitLstNd(GinitIntNd(iBottomLeft, iTopRight));
    hdrNdRoot->ptrFirstNd->ptrChildLst = hdrNdTree;
	hdrNdRoot->uiCnt = 1;

	return hdrNdRoot;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x4208
movq %rax, %r14
leaq 0xfebc(%rip), %rax      # 0x17364
movslq (%rax), %r12
movl $0x8, %esi
movq %r12, %rdi
callq 0x31b0
movq %rax, %r15
movl $0x8, %esi
movq %r12, %rdi
callq 0x31b0
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x7546
movl %r12d, %edx
xorl %esi, %esi
testl %edx, %edx
jle 0x753a
movq (%rcx), %rdi
movq 0x8(%rdi), %rdi
movq (%rdi), %rdi
movq (%rdi), %r8
xorl %r9d, %r9d
movsd (%r8,%r9,8), %xmm0
testb $0x1, %sil
je 0x751c
movsd (%r15,%r9,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x7508
movsd %xmm0, (%r15,%r9,8)
movq 0x8(%rdi), %r10
movsd (%r10,%r9,8), %xmm0
ucomisd (%rax,%r9,8), %xmm0
ja 0x752c
jmp 0x7532
movsd %xmm0, (%r15,%r9,8)
movq 0x8(%rdi), %r10
movsd (%r10,%r9,8), %xmm0
movsd %xmm0, (%rax,%r9,8)
incq %r9
cmpq %r9, %rdx
jne 0x74ea
movq 0x10(%rcx), %rcx
movb $0x1, %sil
testq %rcx, %rcx
jne 0x74d6
movq %r15, %rdi
movq %rax, %rsi
callq 0x692a
movq %rax, %rdi
callq 0x421c
movq %rax, 0x8(%r14)
movq %rbx, 0x8(%rax)
movl $0x1, (%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: distance(double*, double*)
double distance(DataPoint point1, DataPoint point2)
{
	double sum = 0;
	int i;

	for(i=0;i<DIMENSION;i++)
		sum += ( (point1[i]- point2[i])*(point1[i] - point2[i]) );
	
	return sqrt(sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xf82d(%rip), %rax      # 0x17364
movslq (%rax), %rax
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testq %rax, %rax
jle 0x7b63
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm2
subsd (%rsi,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x7b49
ucomisd %xmm1, %xmm0
jb 0x7b6f
sqrtsd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: GisEpsDistant(region*, group*, double)
int GisEpsDistant(Region rgnRect, Group groupElem, double eps)
{   
	int iCnt = 0;
	bool assignflag = false;

	int bIsContains = 0;
	double* point = (Dimension)calloc(DIMENSION, sizeof(double));
	// assert(point != NULL);
	for(iCnt = 0; iCnt < DIMENSION; iCnt++)
    {   
    	point[iCnt] = (rgnRect->iBottomLeft[iCnt] + rgnRect->iTopRight[iCnt])/(double)2;
	}
	// DataPoint d = (dataList->dataClstElem + groupElem->master_id)->iData;

	if(distance(point, groupElem->master) <= eps + DBL_EPSILON)bIsContains = 1;
	else if(distance(point, groupElem->master) < 2*eps + DBL_EPSILON)bIsContains = -1;

	free(point);
	return bIsContains;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r12
leaq 0xf7cf(%rip), %r13      # 0x17364
movslq (%r13), %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x31b0
movq %rax, %rbx
testq %r14, %r14
jle 0x7c0b
movq (%r12), %rax
movq 0x8(%r12), %rcx
xorl %edx, %edx
movsd 0xa5af(%rip), %xmm0     # 0x12170
movsd (%rax,%rdx,8), %xmm1
addsd (%rcx,%rdx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rdx,8)
incq %rdx
cmpq %rdx, %r14
jne 0x7bc1
leaq 0x28(%r15), %r12
testl %r14d, %r14d
jle 0x7c18
movq 0x28(%r15), %rax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm1
subsd (%rax,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %r14
jne 0x7bef
jmp 0x7c1c
addq $0x28, %r15
xorpd %xmm0, %xmm0
movq %r15, %r12
jmp 0x7c1c
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x7c2c
sqrtsd %xmm0, %xmm0
jmp 0x7c31
callq 0x3230
movsd -0x30(%rbp), %xmm3
movsd 0xa53a(%rip), %xmm1     # 0x12178
addsd %xmm3, %xmm1
movl $0x1, %r14d
ucomisd %xmm0, %xmm1
jae 0x7cb0
movslq (%r13), %rax
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testq %rax, %rax
jle 0x7c7f
movq (%r12), %rcx
xorl %edx, %edx
movsd (%rbx,%rdx,8), %xmm2
subsd (%rcx,%rdx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x7c65
ucomisd %xmm1, %xmm0
jb 0x7c8b
sqrtsd %xmm0, %xmm0
jmp 0x7c95
callq 0x3230
movsd -0x30(%rbp), %xmm3
addsd %xmm3, %xmm3
addsd 0xa4d7(%rip), %xmm3     # 0x12178
xorl %r14d, %r14d
ucomisd %xmm0, %xmm3
jbe 0x7cb0
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x3310
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: createCellRegOfPoint(data*, double)
Region createCellRegOfPoint(Data currDataPoint, double eps)
{
	Region tempRegion = (Region) calloc(1, sizeof(struct region));
	// assert(tempRegion!=NULL);

	tempRegion->iBottomLeft = (Dimension)calloc(DIMENSION, sizeof(double));
	// assert(tempRegion->iBottomLeft!=NULL);

	tempRegion->iTopRight = (Dimension)calloc(DIMENSION, sizeof(double));
	// assert(tempRegion->iTopRight!=NULL);

	int i = 0;
	for(i=0;i<DIMENSION;i++)
	{
		tempRegion->iBottomLeft[i] = currDataPoint->iData[i] - eps;		
		tempRegion->iTopRight[i] = currDataPoint->iData[i] + eps; 		
	}

	return tempRegion;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x28(%rbp)
movq %rdi, %r12
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
movq %rax, %rbx
leaq 0xec9f(%rip), %rax      # 0x17364
movslq (%rax), %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x31b0
movq %rax, %r15
movq %rax, (%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x31b0
movsd -0x28(%rbp), %xmm1
movq %rax, 0x8(%rbx)
testq %r14, %r14
jle 0x8721
movq (%r12), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%r15,%rdx,8)
movsd (%rcx,%rdx,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r14
jne 0x86fc
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: createCellRegOfDataPoint(double*, double)
Region createCellRegOfDataPoint(DataPoint currDataPoint, double eps)
{
	Region tempRegion = (Region) calloc(1, sizeof(struct region));
	// assert(tempRegion!=NULL);

	tempRegion->iBottomLeft = (Dimension)calloc(DIMENSION, sizeof(double));
	// assert(tempRegion->iBottomLeft!=NULL);

	tempRegion->iTopRight = (Dimension)calloc(DIMENSION, sizeof(double));
	// assert(tempRegion->iTopRight!=NULL);

	int i = 0;

	for(i=0;i<DIMENSION;i++)
	{
		tempRegion->iBottomLeft[i] = currDataPoint[i] - eps;		
		tempRegion->iTopRight[i] = currDataPoint[i] + eps; 		
	}

	return tempRegion;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x28(%rbp)
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
movq %rax, %r14
leaq 0xec03(%rip), %rax      # 0x17364
movslq (%rax), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, (%r14)
movl $0x8, %esi
movq %r15, %rdi
callq 0x31b0
movsd -0x28(%rbp), %xmm2
movq %rax, 0x8(%r14)
testq %r15, %r15
jle 0x87b8
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm0
movapd %xmm0, %xmm1
subsd %xmm2, %xmm1
movsd %xmm1, (%r12,%rcx,8)
addsd %xmm2, %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r15
jne 0x8794
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: insertGroupIntoRTree(GhdrNd*, group*, int, int)
GHdrNd insertGroupIntoRTree(GHdrNd hdrNdTree, Group groupNode, int gMinEntries, int gMaxEntries)
{
	GinsertTree(hdrNdTree, GinitExtNd(groupNode), gMinEntries, gMaxEntries);
		
	if(hdrNdTree->uiCnt > 1)
		hdrNdTree = GcreateRoot(hdrNdTree);

	return hdrNdTree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
movq %rax, %r13
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
movl (%r12), %ecx
movl %ecx, 0x8(%rax)
movl $0x1, (%r13)
movq %rax, 0x8(%r13)
movq %rbx, %rdi
movq %r13, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x6ef3
cmpl $0x2, (%rbx)
jb 0x8eaa
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x748b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: populateAuxRTrees(dataHdr*, vectorc*)
void populateAuxRTrees(DataHdr dataList, struct vectorc* groupList)
{
	int cnt = 0,i = 0;
	int j=0;
	RHdrNd hdrNdTree = NULL;
	Group g;
	Data data;
	for(i=0; i < VECTOR_TOTAL(groupList); i++)
	{
		g = groupList->groupItems[i];
		
		hdrNdTree = RinitHdrNd();
		
		hdrNdTree->ptrFirstNd = RinitLstNd(RinitIntNd(NULL, NULL));
		hdrNdTree->uiCnt++;
		hdrNdTree->ptrFirstNd->ptrChildLst = RinitHdrNd();		

		for(j=0;j<VECTOR_TOTAL(g->total_points);j++)
		{
			data = dataList->dataClstElem + g->total_points->intItems[j];

			// if(data->debugPoint == TRUE){
			// 	printf("%lf\t%lf\t%lf\t populateAuxRTrees Method is getting inserted in rtree groupId%d\n",data->iData[0],data->iData[1],data->iData[2],g->total_points->intItems[j]);
			// }

			RinsertTree(hdrNdTree, RinitExtNd(data));
					
			if(hdrNdTree->uiCnt > 1)
				hdrNdTree = RcreateRoot(hdrNdTree);

		}
		// if(hdrNdTree == NULL)fprintf(stderr, "Errorrrrrr!\n");
		g->bcell->auxCellRTree = hdrNdTree;
		// isCorrectRTree(g->bcell->auxCellRTree);

	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3a4d
testl %eax, %eax
jle 0x8f94
xorl %r12d, %r12d
movq %rbx, -0x30(%rbp)
movq (%rbx), %rax
movq (%rax,%r12,8), %r13
callq 0x437c
movq %rax, %r15
xorl %edi, %edi
xorl %esi, %esi
callq 0x5279
movq %rax, %rdi
callq 0x4390
movq %rax, 0x8(%r15)
incl (%r15)
callq 0x437c
movq 0x8(%r15), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r13), %rdi
callq 0x3a4d
testl %eax, %eax
jle 0x8f72
xorl %ebx, %ebx
movq 0x10(%r13), %rax
movq 0x8(%rax), %rax
movslq (%rax,%rbx,4), %rdi
shlq $0x6, %rdi
addq 0x8(%r14), %rdi
callq 0x52c3
movq %r15, %rdi
movq %rax, %rsi
callq 0x627d
cmpl $0x2, (%r15)
jb 0x8f5f
movq %r15, %rdi
callq 0x530f
movq %rax, %r15
incq %rbx
movq 0x10(%r13), %rdi
callq 0x3a4d
cltq
cmpq %rax, %rbx
jl 0x8f2a
movq 0x38(%r13), %rax
movq %r15, 0x20(%rax)
incq %r12
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x3a4d
cltq
cmpq %rax, %r12
jl 0x8ee7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: freeGRTree(GhdrNd*)
void freeGRTree(GHdrNd hdrNdTree)
{

	if(hdrNdTree == NULL) 
		return;

	else if(hdrNdTree->uiCnt == 0)
	{
		free(hdrNdTree);
		return;
	}
	
	GLstNd lstNdTemp = hdrNdTree->ptrFirstNd;
	GLstNd lstNdNextTemp;
	
	if(lstNdTemp!=NULL)
	{
		while(lstNdTemp != NULL)
    	{
			switch(lstNdTemp->tnInfo->ndType)
        	{   
        		case INTNODE:   
					lstNdNextTemp = lstNdTemp->ptrNextNd;
	    			free(lstNdTemp->tnInfo->tdInfo->rgnRect->iBottomLeft);
	    			free(lstNdTemp->tnInfo->tdInfo->rgnRect->iTopRight);
	    			free(lstNdTemp->tnInfo->tdInfo->rgnRect);
	    			free(lstNdTemp->tnInfo->tdInfo);
	    			free(lstNdTemp->tnInfo);
	    			freeGRTree(lstNdTemp->ptrChildLst);                            	
	            	free(lstNdTemp);
            	break;
            	case EXTNODE:   	
		            lstNdNextTemp = lstNdTemp->ptrNextNd;
		            free(lstNdTemp->tnInfo->tdInfo);

		            free(lstNdTemp->tnInfo);
		            freeGRTree(lstNdTemp->ptrChildLst);
                	free(lstNdTemp);
                break;

			}
			
			lstNdTemp = lstNdNextTemp;
		}
	}	
	
	free(hdrNdTree);	
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x904c
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x903a
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x903a
movq (%r14), %rax
movl (%rax), %ecx
cmpl $0x1, %ecx
je 0x900f
testl %ecx, %ecx
jne 0x8fc2
movq 0x10(%r14), %r15
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x3310
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x3310
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x3310
movq (%r14), %rax
jmp 0x9013
movq 0x10(%r14), %r15
movq 0x8(%rax), %rdi
callq 0x3310
movq (%r14), %rdi
callq 0x3310
movq 0x8(%r14), %rdi
callq 0x8fa3
movq %r14, %rdi
callq 0x3310
movq %r15, %r14
jmp 0x8fc2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3310
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/partition.cpp
// Function: compute_local_bounding_box(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, int*, interval*)
void compute_local_bounding_box(vector< vector<double> >& objects, int* num_points, interval* box)
{
	int i, j;

	for(i = 0; i < DIMENSION; i++)
	{
		box[i].upper = (objects)[0][i];
		box[i].lower = (objects)[0][i];
	}

	for(i = 0; i < DIMENSION; i++)
	{
		for(j = 1; j < *num_points; j++)
		{
			if(box[i].lower > (objects)[j][i])
				box[i].lower = (objects)[j][i];
			else if(box[i].upper < (objects)[j][i])
				box[i].upper = (objects)[j][i];
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq 0xdb4f(%rip), %rax      # 0x17364
movslq (%rax), %rax
testq %rax, %rax
jle 0x98c6
movq (%rdi), %rcx
movq (%rcx), %rcx
leaq (,%rax,8), %r8
xorl %r9d, %r9d
movsd (%rcx,%r9), %xmm0
movsd %xmm0, 0x8(%rdx,%r9,2)
movsd %xmm0, (%rdx,%r9,2)
addq $0x8, %r9
cmpq %r9, %r8
jne 0x9832
testl %eax, %eax
jle 0x98c6
movl (%rsi), %ecx
movq (%rdi), %rsi
movq %rcx, %rdi
shlq $0x3, %rdi
leaq (%rdi,%rdi,2), %rdi
xorl %r8d, %r8d
cmpl $0x2, %ecx
jl 0x98be
movq %r8, %r10
shlq $0x4, %r10
leaq (%rdx,%r10), %r9
addq %rdx, %r10
addq $0x8, %r10
movsd -0x8(%r10), %xmm0
movl $0x18, %r11d
movq (%rsi,%r11), %rbx
movsd (%rbx,%r8,8), %xmm1
ucomisd %xmm1, %xmm0
movq %r9, %rbx
movapd %xmm1, %xmm2
ja 0x98ad
ucomisd (%r10), %xmm1
movq %r10, %rbx
movapd %xmm0, %xmm2
jbe 0x98b5
movsd %xmm1, (%rbx)
movapd %xmm2, %xmm0
addq $0x18, %r11
cmpq %r11, %rdi
jne 0x9888
incq %r8
cmpq %rax, %r8
jne 0x9865
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/partition.cpp
// Function: compute_global_bounding_box(interval*, interval*, int)
void compute_global_bounding_box(Interval box, Interval gbox, int nproc)
{
	int i, j, k;

	Interval gather_local_box = (Interval) calloc(DIMENSION * nproc, sizeof(struct interval));
	// assert(gather_local_box != NULL);

	MPI_Allgather(box, sizeof(struct interval) * DIMENSION, MPI_BYTE, gather_local_box, 
			sizeof(struct interval) * DIMENSION, MPI_BYTE, MPI_COMM_WORLD);

	for(i = 0; i < DIMENSION; i++)
	{
		gbox[i].lower = gather_local_box[i].lower;
		gbox[i].upper = gather_local_box[i].upper;

		k = i;
		for(j = 0; j < nproc; j++, k += DIMENSION)
		{
			if(gbox[i].lower > gather_local_box[k].lower)
				gbox[i].lower = gather_local_box[k].lower;

			if(gbox[i].upper < gather_local_box[k].upper)
				gbox[i].upper = gather_local_box[k].upper;
		}
	}

	free(gather_local_box);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
leaq 0xda7e(%rip), %rax      # 0x17364
movl (%rax), %r13d
movl %r13d, %eax
imull %edx, %eax
movslq %eax, %rdi
movl $0x10, %esi
callq 0x31b0
movq %rax, %r15
shll $0x4, %r13d
movq 0xd69e(%rip), %rax      # 0x16fa8
movq %rax, (%rsp)
movq 0xd683(%rip), %rdx      # 0x16f98
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %rcx
movl %r13d, %r8d
movq %rdx, %r9
callq 0x3060
leaq 0xda34(%rip), %rax      # 0x17364
movslq (%rax), %rax
testq %rax, %rax
jle 0x99b2
movq %r15, %rcx
addq $0x8, %rcx
movq %rax, %rdx
shlq $0x4, %rdx
xorl %esi, %esi
movq %rsi, %rdi
shlq $0x4, %rdi
movsd (%r15,%rdi), %xmm0
movsd %xmm0, (%r14,%rdi)
movsd 0x8(%r15,%rdi), %xmm1
movsd %xmm1, 0x8(%r14,%rdi)
testl %ebx, %ebx
jle 0x99a6
addq %r14, %rdi
movl %ebx, %r8d
movq %rcx, %r9
movsd -0x8(%r9), %xmm2
ucomisd %xmm2, %xmm0
jbe 0x998a
movsd %xmm2, (%rdi)
movapd %xmm2, %xmm0
movsd (%r9), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x999e
movsd %xmm2, 0x8(%rdi)
movapd %xmm2, %xmm1
addq %rdx, %r9
decl %r8d
jne 0x9976
incq %rsi
addq $0x10, %rcx
cmpq %rax, %rsi
jne 0x9948
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/partition.cpp
// Function: copy_global_box_to_each_node(interval**, interval*, int)
void copy_global_box_to_each_node(Interval* nodes_gbox, Interval gbox, int internal_nodes)
{
	int i, j;
	for(i = 0; i < internal_nodes; i++)
	{
		for(j = 0; j < DIMENSION; j++)
		{
			nodes_gbox[i][j].upper = gbox[j].upper;
			nodes_gbox[i][j].lower = gbox[j].lower;
		}
	}
}

// Assembly:
testl %edx, %edx
jle 0x9a1c
pushq %rbp
movq %rsp, %rbp
leaq 0xd98d(%rip), %rax      # 0x17364
movl (%rax), %eax
movl %edx, %ecx
movq %rax, %rdx
shlq $0x4, %rdx
xorl %r8d, %r8d
testl %eax, %eax
jle 0x9a13
movq (%rdi,%r8,8), %r9
xorl %r10d, %r10d
movsd 0x8(%rsi,%r10), %xmm0
movsd %xmm0, 0x8(%r9,%r10)
movsd (%rsi,%r10), %xmm0
movsd %xmm0, (%r9,%r10)
addq $0x10, %r10
cmpq %r10, %rdx
jne 0x99f0
incq %r8
cmpq %rcx, %r8
jne 0x99e5
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/partition.cpp
// Function: findKMedian(vectorc*, int)
double findKMedian(vectorc* A, int K)
{
	int l,m;
	l=0;

	m = VECTOR_TOTAL(A) - 1;
	while (l<m) 
	{
		double x=A->doubleItems[K];
		int i=l;
		int j=m;
		do {
			while (A->doubleItems[i] < x) i++;
			while (x<A->doubleItems[j]) j--;
			if (i<=j) 
			{
				swap(A->doubleItems[i], A->doubleItems[j]);
				i++; 
				j--;
			}
		} while (i<=j);

		if (j<K) l=i;
		if (K<i) m=j;
	}

	return A->doubleItems[K];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x3a4d
cmpl $0x1, %eax
jle 0x9aaf
decl %eax
movq 0x10(%r14), %rcx
movslq %ebx, %rdx
xorl %esi, %esi
movsd (%rcx,%rdx,8), %xmm0
movl %esi, %r8d
movl %eax, %edi
movslq %r8d, %r9
decq %r9
movl %r8d, %r10d
movsd 0x8(%rcx,%r9,8), %xmm1
incq %r9
incl %r10d
ucomisd %xmm1, %xmm0
ja 0x9a51
leal -0x1(%r10), %r8d
movslq %edi, %r11
incq %r11
movsd -0x8(%rcx,%r11,8), %xmm2
decq %r11
decl %edi
ucomisd %xmm0, %xmm2
ja 0x9a6e
cmpq %r11, %r9
jle 0x9a89
incl %edi
jmp 0x9a98
movsd %xmm2, (%rcx,%r9,8)
movsd %xmm1, (%rcx,%r11,8)
movl %r10d, %r8d
cmpl %edi, %r8d
jle 0x9a48
cmpl %ebx, %edi
cmovll %r8d, %esi
cmpl %ebx, %r8d
cmovgl %edi, %eax
cmpl %eax, %esi
jl 0x9a3e
jmp 0x9ab6
movq 0x10(%r14), %rcx
movslq %ebx, %rdx
movsd (%rcx,%rdx,8), %xmm0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/partition.cpp
// Function: get_median(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, int*, int, ompi_communicator_t*&)
double get_median(vector< vector< double> >& objects, int* num_points, int d, MPI_Comm& new_comm)
{	
	double median;

	// vector<double> data;
	vectorc* data = (vectorc*)malloc(sizeof(struct vectorc));
	// assert(data != NULL);

	VECTOR_INIT(data, DOUBLE);
	addHelper[0] = 0; 
	VECTOR_RESIZE(data, *num_points, (void*)addHelper);
	// data.resize(*num_points, 0);

	for (int k=0; k < *num_points; k++)
		data->doubleItems[k] = (objects)[k][d];

	median = findKMedian(data, VECTOR_TOTAL(data)/2);

	VECTOR_FREE(data);
	free(data);

	// data.clear();

	int proc_count;
	MPI_Comm_size(new_comm, &proc_count);

	vectorc* all_medians = (vectorc*)malloc(sizeof(struct vectorc));
	// assert(all_medians!=NULL);

	VECTOR_INIT(all_medians, DOUBLE);
	VECTOR_RESIZE(all_medians, proc_count, (void*)addHelper);

	// vector<double> all_medians;
	// all_medians.resize(proc_count);

	MPI_Allgather(&median, 1, MPI_DOUBLE, &all_medians->doubleItems[0], 1, MPI_DOUBLE, new_comm);	

	median = findKMedian(all_medians, VECTOR_TOTAL(all_medians)/2); 

	VECTOR_FREE(all_medians);
	free(all_medians);

	// all_medians.clear();	

	return median;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %r13
movq %rdi, %r12
movl $0x30, %edi
callq 0x33a0
movq %rax, %r15
movq %rax, %rdi
movl $0x2, %esi
callq 0x39bc
leaq 0xd892(%rip), %rax      # 0x17390
movq (%rax), %rdx
movl $0x0, (%rdx)
movl (%r13), %esi
movq %r15, %rdi
callq 0x3a56
movslq (%r13), %rax
testq %rax, %rax
jle 0x9b43
movq (%r12), %rcx
movslq %r14d, %rdx
movq 0x10(%r15), %rsi
xorl %edi, %edi
movq (%rcx), %r8
movsd (%r8,%rdx,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
addq $0x18, %rcx
cmpq %rdi, %rax
jne 0x9b29
movq %r15, %rdi
callq 0x3a4d
movl %eax, %esi
shrl $0x1f, %esi
addl %eax, %esi
sarl %esi
movq %r15, %rdi
callq 0x9a1d
leaq -0x38(%rbp), %r14
movsd %xmm0, (%r14)
movq %r15, %rdi
callq 0x3ca8
movq %r15, %rdi
callq 0x3310
movq (%rbx), %rdi
leaq -0x2c(%rbp), %r12
movq %r12, %rsi
callq 0x32e0
movl $0x30, %edi
callq 0x33a0
movq %rax, %r15
movq %rax, %rdi
movl $0x2, %esi
callq 0x39bc
movl (%r12), %esi
leaq 0xd7e7(%rip), %rax      # 0x17390
movq (%rax), %rdx
movq %r15, %rdi
callq 0x3a56
movq 0x10(%r15), %rcx
movq (%rbx), %rax
movq %rax, (%rsp)
movq 0xd3f2(%rip), %rdx      # 0x16fb8
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %r8d
movq %rdx, %r9
callq 0x3060
movq %r15, %rdi
callq 0x3a4d
movl %eax, %esi
shrl $0x1f, %esi
addl %eax, %esi
sarl %esi
movq %r15, %rdi
callq 0x9a1d
movsd %xmm0, (%r14)
movq %r15, %rdi
callq 0x3ca8
movq %r15, %rdi
callq 0x3310
movsd (%r14), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/partition.cpp
// Function: updatePoints(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, vectorc*, vectorc*, int)
bool updatePoints(vector< vector<int> >& raw_ind, vectorc* remote_Indices, vectorc* remote_PrIDs, int remote_number)
{
	int i, source = -1, j = -1, prev_source = -1;

	addHelper[0] = -1;
	VECTOR_RESIZE(remote_Indices, remote_number, (void*)addHelper);

	// remote_Indices.resize(remote_number, -1);

	for(i = 0; i < remote_number; i++)
	{
		source = remote_PrIDs->intItems[i];

		if(source != prev_source)
			j = 0;

		remote_Indices->intItems[i] = raw_ind[source][j++];

		prev_source = source;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0xcac7(%rip), %rax      # 0x17390
movq (%rax), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
movq %rsi, %rdi
movl %ecx, %esi
callq 0x3a56
testl %ebx, %ebx
jle 0xa92b
movq 0x8(%r15), %rax
movq (%r12), %rcx
movq 0x8(%r14), %rdx
movl %ebx, %esi
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
xorl %edi, %edi
xorl %r8d, %r8d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movslq (%rax,%r8,4), %r11
cmpl %r10d, %r11d
cmovnel %edi, %r9d
leaq (%r11,%r11,2), %r10
movslq %r9d, %rbx
incl %r9d
movq (%rcx,%r10,8), %r10
movl (%r10,%rbx,4), %r10d
movl %r10d, (%rdx,%r8,4)
incq %r8
movl %r11d, %r10d
cmpq %r8, %rsi
jne 0xa8ff
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/clustering.cpp
// Function: trivial_decompression(std::vector<int, std::allocator<int>>*, int, int, int, double&)
void trivial_decompression(vector<int>* data, int nproc, int rank, int round, double& dcomtime)
{
	double start = MPI_Wtime();

	vector <int> parser;
	parser.reserve((*data).size());
	parser = (*data);
	(*data).clear();

	int pid_count = parser[0], pos, i, j, pid, npid, npid_count;
	
	pos++;

	while(pid_count > 0)
	{
		pid = parser[pos++];
		npid_count = parser[pos++];

		for(j = 0; j < npid_count; j++)
		{
			(*data).push_back(pid);
			(*data).push_back(parser[pos++]);
		}

		pid_count--;
	}

	parser.clear();

	double stop = MPI_Wtime();

	dcomtime += (stop - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rdi, %r14
callq 0x3360
movsd %xmm0, -0x60(%rbp)
xorpd %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movapd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x2, %rsi
callq 0x10030
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0xca9a
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0xcc8a
movq %rax, 0x8(%r14)
movq -0x50(%rbp), %rax
movl (%rax), %r12d
testl %r12d, %r12d
jle 0xcd43
movq %rbx, -0x58(%rbp)
movslq %edx, %rax
movq -0x50(%rbp), %rcx
movl (%rcx,%rax,4), %edx
movl %edx, -0x2c(%rbp)
leal 0x2(%rax), %edx
movl 0x4(%rcx,%rax,4), %ebx
testl %ebx, %ebx
jle 0xcd29
movl %edx, -0x30(%rbp)
movslq %edx, %r15
shlq $0x2, %r15
negl %ebx
xorl %r13d, %r13d
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
cmpq %rax, %rsi
je 0xcce1
movl -0x2c(%rbp), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xccf5
movq %r14, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x5002
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
movq -0x50(%rbp), %rdx
addq %r15, %rdx
cmpq %rax, %rsi
je 0xcd0f
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xcd17
movq %r14, %rdi
callq 0x5002
addq $0x4, %r15
decl %r13d
cmpl %r13d, %ebx
jne 0xccc5
movl -0x30(%rbp), %edx
subl %r13d, %edx
leal -0x1(%r12), %eax
cmpl $0x1, %r12d
movl %eax, %r12d
jg 0xcc9e
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rbx
cmpq %rax, -0x48(%rbp)
je 0xcd4d
movq %rax, -0x48(%rbp)
callq 0x3360
subsd -0x60(%rbp), %xmm0
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xcd6d
callq 0x3270
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcd80
jmp 0xcd80
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xcd91
callq 0x3270
movq %rbx, %rdi
callq 0x34c0
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/main.cpp
// Function: populateSingle(dataHdr**, char*, int*, int*)
int populateSingle(DataHdr* dataList, char* argv, int* totalSize, int* dims)
{

	vector< vector<double> > objects;

	int localSize = fileReadSingle(argv, totalSize, dims, objects);

	*dataList = initDataHdr(objects.size());

	populateDataListLocal(*dataList, objects);

	return localSize;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x9060
movl %eax, %ebx
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %edi # imm = 0xAAAAAAAB
callq 0x3d3b
movq %rax, (%r14)
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3fa8
leaq -0x30(%rbp), %rdi
callq 0x41b4
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x41b4
movq %rbx, %rdi
callq 0x34c0
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/main.cpp
// Function: createDebugCSV(dataHdr*, int)
void createDebugCSV(DataHdr dataList, int rank)
{
	FILE* debug1;
	string currFile1("");

	currFile1 = debugFileName + patch::to_string(rank);

	debug1 = fopen(currFile1.c_str(), "w");

	printf("Before Remote Points Procedure %d \n",rank);
	for(int i = 0; i < dataList->localCnt; i++)
	{
		Data datai = dataList->dataClstElem + i;
		if(debug1!=NULL){
			fprintf(debug1, "%lf\t%lf\t%lf\t%d\n",datai->iData[0],datai->iData[1],datai->iData[2],(int)datai->core_tag); 

		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq -0x2c(%rbp), %r14
movl %esi, (%r14)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x1c36(%rip), %rdx      # 0x12029
leaq -0x50(%rbp), %rdi
movq %rdx, %rsi
callq 0xbad8
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0xb3f7
leaq 0x6ece(%rip), %r14      # 0x172e0
movq %r14, %rdi
callq 0x3120
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0x32c0
leaq -0x80(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x10454
movq %rdx, -0x90(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x80(%rbp)
jmp 0x1045b
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x90(%rbp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x3340
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x10492
callq 0x3270
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x104a4
callq 0x3270
movq -0x50(%rbp), %rdi
leaq 0x1dc5(%rip), %rsi      # 0x12274
callq 0x3300
movq %rax, %r14
movl -0x2c(%rbp), %esi
leaq 0x1def(%rip), %rdi      # 0x122b0
xorl %eax, %eax
callq 0x3050
movl 0x4(%rbx), %eax
testl %eax, %eax
jle 0x1051b
xorl %r13d, %r13d
leaq 0x1dfb(%rip), %r15      # 0x122d4
xorl %r12d, %r12d
testq %r14, %r14
je 0x1050c
movq 0x8(%rbx), %rax
movq (%rax,%r13), %rcx
movsd (%rcx), %xmm0
movsd 0x8(%rcx), %xmm1
movsd 0x10(%rcx), %xmm2
movl 0x28(%rax,%r13), %edx
movq %r14, %rdi
movq %r15, %rsi
movb $0x3, %al
callq 0x3400
movl 0x4(%rbx), %eax
incq %r12
movslq %eax, %rcx
addq $0x40, %r13
cmpq %rcx, %r12
jl 0x104dc
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x1052d
callq 0x3270
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10556
callq 0x3270
jmp 0x10556
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x10568
callq 0x3270
movq %rbx, %rdi
callq 0x34c0
// File: /workspace/github_cpp_makefile_star2_O3/Gilaverbuch[P]FD_2D_WAVE/wave.cpp
// Function: main
int main()
{	

	model_parameters model;
	model.print_parameters();
	Field displacement(model);
	displacement.Propagator();

	// std::cout << "number of elements" << " " << elements_ << std::endl;
	// int n=10;
	// int a[n] = {};

	// std::cout << a[0] << " " << a[5] << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
leaq -0xa0(%rbp), %rbx
movq %rbx, %rdi
callq 0x25b0
movq %rbx, %rdi
callq 0x2c82
leaq -0x130(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x35dc
leaq -0x130(%rbp), %rdi
callq 0x3a5e
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x2503
movq -0x10(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x2518
movq -0x28(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x252d
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
xorl %eax, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %rbp
retq
jmp 0x253b
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x2552
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/Gilaverbuch[P]FD_2D_WAVE/Field.cpp
// Function: Field::initialize(int, int, double**, std::vector<int, std::allocator<int>>, std::vector<double, std::allocator<double>>)
void Field::initialize(int size_y, int size_x, double **A, std::vector<int>  x_range, std::vector<double> val){

	int i, k, j, pos1, pos2;
	pos1 = 0;

	for (k=0; k<int(x_range.size()); k++){

		pos2 = int(x_range[k]/dx);

		for (i=pos1; i<pos2; i++){

			for (j=0; j<size_x; j++){

				A[i][j] = val[k];

			}
		}
		pos1 = pos2; 
	}
	
}

// Assembly:
movq (%r8), %r10
movq 0x8(%r8), %r8
subq %r10, %r8
shrq $0x2, %r8
testl %r8d, %r8d
jle 0x3a5d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %esi
movl 0x70(%rdi), %edi
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movl %edx, %r11d
xorl %ebx, %ebx
xorl %r14d, %r14d
movl (%r10,%rbx,4), %eax
cltd
idivl %edi
cmpl %eax, %r14d
jge 0x3a4a
movslq %r14d, %rdx
movslq %eax, %r14
testl %esi, %esi
jle 0x3a42
movq (%r9), %r12
movq (%rcx,%rdx,8), %r15
movsd (%r12,%rbx,8), %xmm0
xorl %r12d, %r12d
movsd %xmm0, (%r15,%r12,8)
incq %r12
cmpq %r12, %r11
jne 0x3a34
incq %rdx
cmpq %r14, %rdx
jne 0x3a20
incq %rbx
movl %eax, %r14d
cmpq %r8, %rbx
jne 0x3a0e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/vividvilla[P]hackerrank/src/candies.cpp
// Function: getMinimumCandies(std::vector<int, std::allocator<int>>)
int getMinimumCandies(vector<int> c) {
    int N = c.size();
    vector<int> minR = vector<int>(N, 1);
    vector<int> minL = vector<int>(N, 1);

    for (int i = N - 2; i >= 0; i--) {
        if (c[i + 1] < c[i])
            minR[i] = 1 + minR[i + 1];
    }

    for (int i = 1; i < N; i++) {
        if (c[i - 1] < c[i])
            minL[i] = 1 + minL[i - 1];
    }

    int t = 0;
    for (int i = 0; i < N; i++)
        t += max(minR[i], minL[i]);

    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r12
subq (%rdi), %r12
shrq $0x2, %r12
movslq %r12d, %r14
movl $0x1, %ebp
leaq 0x28(%rsp), %rdx
movl %ebp, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %r15
movq %r14, %rsi
movq %r15, %rcx
callq 0x14e4
movl %ebp, (%r15)
leaq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rdx
leaq 0xb(%rsp), %rcx
movq %r14, %rsi
callq 0x14e4
cmpl $0x1, %r12d
jle 0x1309
leal -0x2(%r12), %eax
movq (%rbx), %rcx
movq 0x10(%rsp), %rdx
incq %rax
movl (%rcx,%rax,4), %esi
cmpl -0x4(%rcx,%rax,4), %esi
jge 0x12cc
movl (%rdx,%rax,4), %esi
incl %esi
movl %esi, -0x4(%rdx,%rax,4)
decq %rax
jg 0x12ba
movq 0x28(%rsp), %rdi
cmpl $0x2, %r12d
jl 0x130e
movq (%rbx), %rax
movl %r12d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl $0x1, %edx
movl -0x4(%rax,%rdx,4), %esi
cmpl (%rax,%rdx,4), %esi
jge 0x12ff
movl -0x4(%rdi,%rdx,4), %esi
incl %esi
movl %esi, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x12ed
jmp 0x130e
movq 0x28(%rsp), %rdi
testl %r12d, %r12d
jle 0x133a
movq 0x10(%rsp), %rax
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %ecx, %ecx
xorl %ebx, %ebx
movl (%rax,%rcx,4), %edx
movl (%rdi,%rcx,4), %esi
cmpl %esi, %edx
cmovgl %edx, %esi
addl %esi, %ebx
incq %rcx
cmpq %rcx, %r12
jne 0x1323
jmp 0x1341
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x134e
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1365
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x138e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/vividvilla[P]hackerrank/src/candies.cpp
// Function: main
int main() {
    int N, x;
    cin >> N;

    vector<int> c;
    for (int i = 0; i < N; i++) {
        cin >> x;
        c.push_back(x);
    }

    cout << getMinimumCandies(c) << endl;

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x2c39(%rip), %rdi      # 0x3fe0
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x1060
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x0, (%rbx)
jle 0x1418
xorl %ebp, %ebp
movq 0x2c0d(%rip), %rbx      # 0x3fe0
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1060
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x1405
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x1410
movq %r15, %rdi
movq %r14, %rdx
callq 0x16fc
incl %ebp
cmpl 0xc(%rsp), %ebp
jl 0x13dd
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1660
leaq 0x30(%rsp), %rdi
callq 0x124c
movq 0x2b98(%rip), %rdi      # 0x3fd0
movl %eax, %esi
callq 0x10f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1480
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1497
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14c2
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x14c5
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
jmp 0x14c5
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14dc
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/tree/./tree.h
// Function: problem_t::fill_noisy_states()
void fill_noisy_states() {
        if( r_ > 0.0 ) {
            Problem::hash_t<state_t> hash(*this);
            Algorithm::state_space_t<state_t> state_space(*this);
            state_space.generate_space(init_, hash);
            for( Problem::hash_t<state_t>::const_iterator hi = hash.begin(); hi != hash.end(); ++hi ) {
                if( Random::real() < r_ ) noisy_.insert((*hi).first);
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
xorps %xmm0, %xmm0
ucomiss 0x24(%rdi), %xmm0
jae 0x89fd
movq %rdi, %rbx
leaq 0x48(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq $0x0, 0x8(%rax)
leaq 0x2a6cf(%rip), %rcx     # 0x33060
movq %rcx, -0x38(%rax)
movq %rdi, 0x10(%rax)
movl $0x0, 0x18(%rax)
leaq 0x8(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %rdx
callq 0x8d0c
movq 0x28(%rsp), %r12
testq %r12, %r12
je 0x89f3
leaq 0x30(%rbx), %r14
movq %rsp, %r15
callq 0x51e0
cvtsd2ss %xmm0, %xmm0
ucomiss 0x24(%rbx), %xmm0
jae 0x89ea
leaq 0x8(%r12), %rsi
movq %r14, (%rsp)
movq %r14, %rdi
movq %r15, %rdx
callq 0x9552
movq (%r12), %r12
testq %r12, %r12
jne 0x89c7
leaq 0x10(%rsp), %rdi
callq 0x12eaa
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8a0b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x12eaa
movq %rbx, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/tree/./tree.h
// Function: state_t::print(std::ostream&) const
void print(std::ostream &os) const {
        bits_t b1(branch1()), b2(data2_);
        os << "( " << depth()
           << " , [" << branch1()
           << "|" << data2_
           << "]:" << b1
           << "|" << b2 << " )";
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3ffffff, %r15d       # imm = 0x3FFFFFF
andl (%rdi), %r15d
movl 0x4(%rdi), %ebp
leaq 0x127fc(%rip), %rsi     # 0x25bc4
movl $0x2, %edx
movq %r14, %rdi
callq 0x5250
movl (%rbx), %esi
shrl $0x1a, %esi
movq %r14, %rdi
callq 0x5160
movq %rax, %r14
leaq 0x127db(%rip), %rsi     # 0x25bc7
movl $0x4, %edx
movq %rax, %rdi
callq 0x5250
movl (%rbx), %esi
andl $0x3ffffff, %esi        # imm = 0x3FFFFFF
movq %r14, %rdi
callq 0x5160
movq %rax, %r14
leaq 0x127b9(%rip), %rsi     # 0x25bcc
movl $0x1, %edx
movq %rax, %rdi
callq 0x5250
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x5160
movq %rax, %rbx
leaq 0x12799(%rip), %rsi     # 0x25bce
movl $0x2, %edx
movq %rax, %rdi
callq 0x5250
movl $0x1f, %r14d
xorl %esi, %esi
btl %r14d, %r15d
setb %sil
movq %rbx, %rdi
callq 0x5160
addl $-0x1, %r14d
jb 0x13448
leaq 0x12765(%rip), %rsi     # 0x25bcc
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5250
movl $0x1f, %r14d
xorl %esi, %esi
btl %r14d, %ebp
setb %sil
movq %rbx, %rdi
callq 0x5160
addl $-0x1, %r14d
jb 0x1347a
leaq 0x12738(%rip), %rsi     # 0x25bd1
movl $0x2, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5250
// File: /workspace/github_cpp_makefile_star2_O3/smuething[P]dune-cxx11/09-initializer_list.cc
// Function: foo(std::initializer_list<int>)
int foo(std::initializer_list<int> il)
{
  int res = 0;
  for (const int* it = il.begin(); it != il.end(); ++it)
    res += *it;
  return res;
}

// Assembly:
testq %rsi, %rsi
je 0x1146
shlq $0x2, %rsi
xorl %ecx, %ecx
xorl %eax, %eax
addl (%rdi,%rcx), %eax
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x1139
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::parseFeatureName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
params_hash
CerebronPredictor::parseFeatureName(string feature_name)
{
	params_hash result;

	vector<string> split_line = split(feature_name , '_');
	result.index = split_line[0];
	result.nbBlock = atoi(split_line[1].c_str());
	
	if(split_line.size() == 3)
		result.xorWithPC = split_line[2] == "1" ? true : false;
	else
		result.xorWithPC = false;
		
	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
callq 0xc932
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xcbd6
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x5f, %edx
callq 0x2e230
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x764c
callq 0x52b0
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x51a0
movq 0x8(%rsp), %r14
movq 0x20(%r14), %rdi
callq 0x54c0
movl %eax, 0x24(%rbx)
movq 0x10(%rsp), %rax
subq %r14, %rax
cmpq $0x60, %rax
jne 0x7692
addq $0x40, %r14
leaq 0x2dff7(%rip), %rsi     # 0x3567a
movq %r14, %rdi
callq 0x50f0
testl %eax, %eax
sete %al
jmp 0x7694
xorl %eax, %eax
movb %al, 0x20(%rbx)
leaq 0x8(%rsp), %rdi
callq 0xc7c2
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xc7c2
jmp 0x76d4
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x76d4
callq 0x52b0
jmp 0x76d4
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x76e5
callq 0x52b0
movq %r14, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::allocateInNVM(unsigned long, Access)
allocDecision
CerebronPredictor::allocateInNVM(uint64_t set, Access element)
{
//	if(element.isInstFetch())
//		return ALLOCATE_IN_NVM;
	
	update_globalPChistory(element.m_pc);
	if( hitInSRAMMissingTags( element.block_addr, set) )
		element.m_pc = missingTagMissPC( element.block_addr , set);
		
	return activationFunction(element.isWrite() , element.block_addr , element.m_pc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq 0x10(%r13), %r15
movq %r15, %rsi
callq 0x27572
movq 0x30(%r13), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x27102
testb %al, %al
je 0x7735
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x26dd0
movq %rax, %r15
movl 0x1c(%r13), %eax
cmpl $0x3, %eax
sete %cl
cmpl $0x6, %eax
sete %al
orb %cl, %al
movzbl %al, %esi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7762
nop
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::classifyRD(int, int, bool)
RD_TYPE
CerebronPredictor::classifyRD(int set , int index, bool inNVM)
{
	vector<CacheEntry*> line;
	int64_t ref_rd = 0;
	if(inNVM)
	{
		ref_rd = m_tableNVM[set][index]->policyInfo;
		line = m_tableNVM[set];
	}
	else
	{
		line = m_tableSRAM[set];
		ref_rd = m_tableSRAM[set][index]->policyInfo;
	}
	
	int position = 0;
	/* Determine the position of the cache line in the LRU stack */
//	debug_file << "classifyRD, cpt_time =  " << cpt_time << ", set = " << set << " col = " << index << ", ref_rd = " << ref_rd << endl;
	for(unsigned i = 0 ; i < line.size() ; i ++)
	{
//		debug_file << "\tPolicy[" << i << "] = " << line[i]->policyInfo << endl;
		if(line[i]->policyInfo > ref_rd && line[i]->isValid)
			position++;
	}	
//	debug_file << "Position = " << position << endl;

	if(simu_parameters.nvm_assoc > simu_parameters.sram_assoc)
	{
		if(position < simu_parameters.mediumrd_def)
			return RD_SHORT;
		else
			return RD_MEDIUM;	
	}
	else
	{
		if(position < simu_parameters.mediumrd_def)
			return RD_SHORT;
		else
			return RD_MEDIUM;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movslq %esi, %rax
testl %ecx, %ecx
je 0x949e
movq 0x10(%r14), %rcx
movq (%rcx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rsi
movslq %ebx, %rax
movq (%rsi), %rcx
movq (%rcx,%rax,8), %rax
movl 0x38(%rax), %ebp
movq %rsp, %rdi
callq 0xc856
jmp 0x94ce
movq 0x8(%r14), %rcx
leaq (%rax,%rax,2), %r15
leaq (,%r15,8), %rsi
addq (%rcx), %rsi
movq %rsp, %rdi
callq 0xc856
movq 0x8(%r14), %rax
movq (%rax), %rax
movslq %ebx, %rcx
movq (%rax,%r15,8), %rax
movq (%rax,%rcx,8), %rax
movl 0x38(%rax), %ebp
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0x950b
sarq $0x3, %rax
xorl %ecx, %ecx
xorl %ebx, %ebx
movq (%rdi,%rcx,8), %rdx
cmpl %ebp, 0x38(%rdx)
jle 0x94f2
movzbl (%rdx), %edx
addl %edx, %ebx
incq %rcx
movl %ecx, %edx
cmpq %rdx, %rax
ja 0x94e4
leaq 0x3ca4d(%rip), %rax     # 0x45f50
movl 0x1fc(%rax), %ebp
jmp 0x951f
leaq 0x3ca3e(%rip), %rax     # 0x45f50
movl 0x1fc(%rax), %ebp
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x9524
callq 0x52b0
xorl %eax, %eax
cmpl %ebp, %ebx
setge %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9547
callq 0x52b0
movq %rbx, %rdi
callq 0x55a0
nop