LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: RisOverLap(region*, region*)
Boolean RisOverLap(Region rgnRectOne, Region rgnRectTwo)
{
	int iDim = 0;
	for(iDim = 0; iDim < DIMENSION; iDim++)
		if(rgnRectOne->iTopRight[iDim] < rgnRectTwo->iBottomLeft[iDim] || rgnRectTwo->iTopRight[iDim] < rgnRectOne->iBottomLeft[iDim])
			return FALSE;
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xf490(%rip), %rax      # 0x14334
movl (%rax), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movl $0x1, %r8d
cmpq %rdx, %rcx
je 0x4ee9
movq 0x8(%rdi), %r9
movq (%rsi), %rax
movsd (%rax,%rdx,8), %xmm0
xorl %eax, %eax
ucomisd (%r9,%rdx,8), %xmm0
ja 0x4eec
movq 0x8(%rsi), %r9
movq (%rdi), %r10
movsd (%r10,%rdx,8), %xmm0
ucomisd (%r9,%rdx,8), %xmm0
leaq 0x1(%rdx), %rdx
jbe 0x4eb3
jmp 0x4eec
movl %r8d, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: freeRTree(RhdrNd*)
void freeRTree(RHdrNd hdrNdTree)
{

	if(hdrNdTree == NULL) 
		return;

	if(hdrNdTree->uiCnt == 0)
	{
		free(hdrNdTree);
		return;
	}
	
	RLstNd lstNdTemp = hdrNdTree->ptrFirstNd;
	RLstNd lstNdNextTemp;
	
	if(lstNdTemp!=NULL)
	{
		while(lstNdTemp != NULL)
    	{
			switch(lstNdTemp->tnInfo->ndType)
        	{   
        		case INTNODE:   
				    			free(lstNdTemp->tnInfo->tdInfo->rgnRect->iBottomLeft);
				    			free(lstNdTemp->tnInfo->tdInfo->rgnRect->iTopRight);
				    			free(lstNdTemp->tnInfo->tdInfo->rgnRect);
				    			free(lstNdTemp->tnInfo->tdInfo);
				    			free(lstNdTemp->tnInfo);				    			
				    			freeRTree(lstNdTemp->ptrChildLst);                            	
                            	lstNdNextTemp = lstNdTemp->ptrNextNd;
                            	free(lstNdTemp);
                            	break;
            	case EXTNODE:   					            
					            free(lstNdTemp->tnInfo->tdInfo);
					            free(lstNdTemp->tnInfo);
					            freeRTree(lstNdTemp->ptrChildLst);
					            lstNdNextTemp = lstNdTemp->ptrNextNd;
                            	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 0x4fd9
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x4fc7
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x4fc7
movq (%r14), %rax
movl (%rax), %ecx
cmpl $0x1, %ecx
je 0x4f9c
testl %ecx, %ecx
jne 0x4f55
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x2280
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x2280
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movq (%r14), %rdi
callq 0x2280
movq 0x8(%r14), %rdi
callq 0x4f36
movq 0x10(%r14), %r15
movq %r14, %rdi
callq 0x2280
movq %r15, %r14
jmp 0x4f55
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2280
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: GinitRgnRect(double*, double*)
Region GinitRgnRect(Dimension iBottomLeft, Dimension iTopRight)
{   

	Region rgnRect = (Region)calloc(1, sizeof(struct region));
	// assert(rgnRect!=NULL);
    
    if(iBottomLeft != NULL)
		rgnRect->iBottomLeft = iBottomLeft;
	else{
		rgnRect->iBottomLeft = (Dimension)calloc(DIMENSION, sizeof(double));
		// assert(rgnRect->iBottomLeft!=NULL);
	}

	if(iTopRight != NULL)
		rgnRect->iTopRight = iTopRight;
	else{
		rgnRect->iTopRight = (Dimension)calloc(DIMENSION, sizeof(double));
		// assert(rgnRect->iTopRight!=NULL);

	}

	return rgnRect;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2180
movq %rax, %rbx
testq %r15, %r15
jne 0x51dd
leaq 0xf165(%rip), %rax      # 0x14334
movslq (%rax), %rdi
pushq $0x8
popq %rsi
callq 0x2180
movq %rax, %r15
movq %r15, (%rbx)
testq %r14, %r14
jne 0x51fa
leaq 0xf148(%rip), %rax      # 0x14334
movslq (%rax), %rdi
pushq $0x8
popq %rsi
callq 0x2180
movq %rax, %r14
movq %r14, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: GinitIntNd(double*, double*)
GTreeNode GinitIntNd(Dimension iBottomLeft, Dimension iTopRight)
{   

	Region rgnRect = GinitRgnRect(iBottomLeft, iTopRight);

	GTreeData tdInfo = (GTreeData)calloc(1, sizeof(*tdInfo));
	// assert(tdInfo!=NULL);

	tdInfo->rgnRect = rgnRect;
	tdInfo->groupElem = -1;
	
    GTreeNode tnInfo = (GTreeNode)calloc(1, sizeof(*tnInfo));
    // assert(tnInfo!=NULL);

	tnInfo->ndType = INTNODE;
	tnInfo->tdInfo = tdInfo;

	return tnInfo;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x51a5
movq %rax, %rbx
pushq $0x1
popq %r14
pushq $0x10
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq %rax, %r12
movq %rbx, (%rax)
orl $-0x1, 0x8(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq %r12, 0x8(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: GinitExtNd(group*)
GTreeNode GinitExtNd(Group groupElem)
{
	// assert(groupElem!=NULL);

	GTreeNode tnInfo = (GTreeNode)calloc(1, sizeof(*tnInfo));
	// assert(tnInfo!=NULL);
	
	GTreeData tdInfo = (GTreeData)calloc(1, sizeof(*tdInfo));
    // assert(tdInfo!=NULL);

	tdInfo->groupElem = groupElem->id;
	tdInfo->rgnRect = NULL;

    tnInfo->ndType = EXTNODE;	
	tnInfo->tdInfo = tdInfo;

	return tnInfo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
pushq $0x10
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movl (%rbx), %ecx
movl %ecx, 0x8(%rax)
movl $0x1, (%r12)
movq %rax, 0x8(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: GsetRect(GlstNd*, GtreeNode*)
void GsetRect(GLstNd lstNd, GTreeNode tnInfo)
{   
	// if(lstNd->tnInfo->ndType)
	// 	fprintf(stderr, "------------------TreeNode: %d\t InsertingNode: %d------------------\n", lstNd->tnInfo->ndType, tnInfo->ndType);

    int iCnt = 0;
    switch(tnInfo->ndType)
    {   
    	case INTNODE:
			for(iCnt = 0; iCnt < DIMENSION; iCnt++)
	        {   
	        	lstNd->tnInfo->tdInfo->rgnRect->iBottomLeft[iCnt] = tnInfo->tdInfo->rgnRect->iBottomLeft[iCnt];
				lstNd->tnInfo->tdInfo->rgnRect->iTopRight[iCnt] = tnInfo->tdInfo->rgnRect->iTopRight[iCnt];
	     	}
			break;
        case EXTNODE:
			for(iCnt = 0; iCnt < DIMENSION; iCnt++)
	        {   
	        	lstNd->tnInfo->tdInfo->rgnRect->iBottomLeft[iCnt] = groupList->groupItems[tnInfo->tdInfo->groupElem]->bcell->minOriginalBoundary[iCnt];
				lstNd->tnInfo->tdInfo->rgnRect->iTopRight[iCnt] = groupList->groupItems[tnInfo->tdInfo->groupElem]->bcell->maxOriginalBoundary[iCnt];
			}
			break;
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rsi), %eax
testl %eax, %eax
je 0x531f
cmpl $0x1, %eax
jne 0x536e
leaq 0xf079(%rip), %rax      # 0x14334
movl (%rax), %eax
leaq 0xf0ac(%rip), %rcx      # 0x14370
movq (%rcx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x536e
movq (%rcx), %r8
movq 0x8(%rsi), %r9
movslq 0x8(%r9), %r9
movq (%r8,%r9,8), %r8
movq 0x38(%r8), %r8
movq (%r8), %r9
movsd (%r9,%rdx,8), %xmm0
movq (%rdi), %r9
movq 0x8(%r9), %r9
movq (%r9), %r9
movq (%r9), %r10
movsd %xmm0, (%r10,%rdx,8)
movq 0x8(%r8), %r8
movsd (%r8,%rdx,8), %xmm0
movq 0x8(%r9), %r8
movsd %xmm0, (%r8,%rdx,8)
incq %rdx
jmp 0x52ce
leaq 0xf00e(%rip), %rax      # 0x14334
movl (%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x536e
movq 0x8(%rsi), %rdx
movq (%rdx), %rdx
movq (%rdx), %r8
movsd (%r8,%rcx,8), %xmm0
movq (%rdi), %r8
movq 0x8(%r8), %r8
movq (%r8), %r8
movq (%r8), %r9
movsd %xmm0, (%r9,%rcx,8)
movq 0x8(%rdx), %rdx
movsd (%rdx,%rcx,8), %xmm0
movq 0x8(%r8), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0x532f
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: GinsertTree(GhdrNd*, GtreeNode*, int, int)
Boolean GinsertTree(GHdrNd hdrNdTree, GTreeNode tnInfo, int gMinEntries, int gMaxEntries)
{   
	int iCnt = 0;

	if(hdrNdTree->ptrFirstNd == NULL || hdrNdTree->ptrFirstNd->tnInfo->ndType == EXTNODE)
    {    
		GinsertLstElem(hdrNdTree, tnInfo);
		return(hdrNdTree->uiCnt > gMaxEntries) ? TRUE : FALSE;
    }
    
	if(hdrNdTree->ptrFirstNd->ptrChildLst->uiCnt == 0)
		GsetRect(hdrNdTree->ptrFirstNd, tnInfo);

	GLstNd lstNdTemp = GpickChild(hdrNdTree, tnInfo);

	if(GinsertTree(lstNdTemp->ptrChildLst, tnInfo, gMinEntries, gMaxEntries))
    {   
        GsplitNode(lstNdTemp,gMinEntries);
	    hdrNdTree->uiCnt++;
	    return (hdrNdTree->uiCnt > gMaxEntries) ? TRUE : FALSE;
	}
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x56fc
movq (%rdi), %rax
cmpl $0x1, (%rax)
jne 0x570c
movq %r14, %rdi
movq %r12, %rsi
callq 0x2f68
cmpl %ebx, (%r14)
jmp 0x5758
movl %edx, %r15d
movq 0x8(%rdi), %rax
cmpl $0x0, (%rax)
jne 0x5720
movq %r12, %rsi
callq 0x52a1
movq %r14, %rdi
movq %r12, %rsi
callq 0x5370
movq %rax, %r13
movq 0x8(%rax), %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %ebx, %ecx
callq 0x56d5
testl %eax, %eax
je 0x576d
movq %r13, %rdi
movl %r15d, %esi
callq 0x5771
movl (%r14), %eax
incl %eax
movl %eax, (%r14)
cmpl %ebx, %eax
seta %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x575b
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2f2c
movq %rax, %r14
leaq 0xe75b(%rip), %rax      # 0x14334
movslq (%rax), %r12
pushq $0x8
popq %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
movq %rax, %r15
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
leaq 0x8(%rbx), %rcx
xorl %esi, %esi
testl %r12d, %r12d
movl $0x0, %edx
cmovgl %r12d, %edx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x5c7b
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x5c72
movq (%rcx), %r8
movq 0x8(%r8), %r8
movq (%r8), %r8
movq (%r8), %r9
movsd (%r9,%rdi,8), %xmm0
testb $0x1, %sil
je 0x5c58
movsd (%r15,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5c45
movsd %xmm0, (%r15,%rdi,8)
movq 0x8(%r8), %r8
movsd (%r8,%rdi,8), %xmm0
ucomisd (%rax,%rdi,8), %xmm0
ja 0x5c68
jmp 0x5c6d
movsd %xmm0, (%r15,%rdi,8)
movq 0x8(%r8), %r8
movsd (%r8,%rdi,8), %xmm0
movsd %xmm0, (%rax,%rdi,8)
incq %rdi
jmp 0x5c15
addq $0x10, %rcx
movb $0x1, %sil
jmp 0x5c0b
movq %r15, %rdi
movq %rax, %rsi
callq 0x520c
movq %rax, %rdi
callq 0x2f4a
movq %rax, 0x8(%r14)
movq %rbx, 0x8(%rax)
movl $0x1, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe140(%rip), %rax      # 0x14334
movl (%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x621d
movsd (%rdi,%rcx,8), %xmm1
subsd (%rsi,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
jmp 0x6201
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x622d
sqrtsd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x28(%rbp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0xe0e0(%rip), %rax      # 0x14334
movslq (%rax), %r12
pushq $0x8
popq %rsi
movq %r12, %rdi
callq 0x2180
movq %rax, %rbx
xorl %eax, %eax
testl %r12d, %r12d
movl $0x0, %ecx
cmovgl %r12d, %ecx
movsd 0x8ed5(%rip), %xmm0     # 0xf150
cmpq %rax, %rcx
je 0x629f
movq (%r15), %rdx
movq 0x8(%r15), %rsi
movsd (%rdx,%rax,8), %xmm1
addsd (%rsi,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
jmp 0x627b
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x61e9
movsd 0x8ea5(%rip), %xmm1     # 0xf158
movsd -0x28(%rbp), %xmm2
addsd %xmm2, %xmm1
ucomisd %xmm0, %xmm1
jae 0x62ec
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x61e9
movsd -0x28(%rbp), %xmm1
addsd %xmm1, %xmm1
addsd 0x8e79(%rip), %xmm1     # 0xf158
xorl %r14d, %r14d
ucomisd %xmm0, %xmm1
jbe 0x62f0
pushq $-0x1
jmp 0x62ee
pushq $0x1
popq %r14
movq %rbx, %rdi
callq 0x2280
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, -0x30(%rbp)
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2180
movq %rax, %r14
leaq 0xd778(%rip), %rax      # 0x14334
movslq (%rax), %r12
pushq $0x8
popq %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
movq %rax, %r15
movq %rax, (%r14)
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
movsd -0x30(%rbp), %xmm1
movq %rax, 0x8(%r14)
xorl %ecx, %ecx
testl %r12d, %r12d
movl $0x0, %edx
cmovgl %r12d, %edx
cmpq %rcx, %rdx
je 0x6c20
movq (%rbx), %rsi
movsd (%rsi,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%r15,%rcx,8)
movsd (%rsi,%rcx,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
jmp 0x6bf6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, -0x30(%rbp)
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2180
movq %rax, %r14
leaq 0xd6d7(%rip), %rax      # 0x14334
movslq (%rax), %r12
pushq $0x8
popq %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
movq %rax, %r15
movq %rax, (%r14)
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
movsd -0x30(%rbp), %xmm2
movq %rax, 0x8(%r14)
xorl %ecx, %ecx
testl %r12d, %r12d
movl $0x0, %edx
cmovgl %r12d, %edx
cmpq %rcx, %rdx
je 0x6cbd
movsd (%rbx,%rcx,8), %xmm0
movapd %xmm0, %xmm1
subsd %xmm2, %xmm1
movsd %xmm1, (%r15,%rcx,8)
addsd %xmm2, %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
jmp 0x6c97
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/MuC_RTree.cpp
// Function: insertPointintoGroup(group*, data*)
void insertPointintoGroup(Group currGroup, Data currDataPoint)
{
	// Data master = data
	DataPoint d = currGroup->master;

	double dist = distance(currDataPoint->iData, d);
	
	currGroup->total_count++;
	addHelper[0] = currDataPoint->id;

	VECTOR_ADD(currGroup->total_points, addHelper);
	double two = 2;

	if(dist <= EPS/two)
	{
		currGroup->inner_count++;
		addHelper[0] = currDataPoint->id;
		VECTOR_ADD(currGroup->inner_points, addHelper);
	}

	if(currGroup->threshold < dist) currGroup->threshold = dist;

	currDataPoint->group_id = currGroup->id;

	BCell currBCell = currGroup->bcell;
	int x,i;

	if(VECTOR_TOTAL(currGroup->total_points) == 1)
	{
		for(x = 0; x < DIMENSION; x++)
		{
			currBCell->minActualBoundary[x] = currDataPoint->iData[x];
			currBCell->maxActualBoundary[x] = currDataPoint->iData[x];
		}		
	}
	else
	{
		for(i = 0; i< DIMENSION; i++)
		{
			if(currBCell->minActualBoundary[i] > currDataPoint->iData[i])
			{
				currBCell->minActualBoundary[i] = currDataPoint->iData[i];
			}

			if(currBCell->maxActualBoundary[i] < currDataPoint->iData[i])
			{
				currBCell->maxActualBoundary[i] = currDataPoint->iData[i];
			}
		}
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rsi
movq (%rbx), %rdi
callq 0x61e9
movsd %xmm0, -0x20(%rbp)
incl 0x1c(%r14)
movl 0x1c(%rbx), %eax
leaq 0xd501(%rip), %r15      # 0x14360
movq (%r15), %rsi
movl %eax, (%rsi)
movq 0x10(%r14), %rdi
callq 0x29f0
leaq 0xd4b4(%rip), %rax      # 0x14328
movsd (%rax), %xmm0
mulsd 0x82d0(%rip), %xmm0     # 0xf150
ucomisd -0x20(%rbp), %xmm0
jb 0x6e9c
incl 0x18(%r14)
movl 0x1c(%rbx), %eax
movq (%r15), %rsi
movl %eax, (%rsi)
movq 0x8(%r14), %rdi
callq 0x29f0
fldt 0x40(%r14)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
fldl -0x28(%rbp)
fucomi %st(1), %st
fstp %st(1)
jbe 0x6eb9
fstpt 0x40(%r14)
fldz
fstp %st(0)
movl (%r14), %eax
movl %eax, 0x20(%rbx)
movq 0x10(%r14), %rdi
movq 0x38(%r14), %r14
callq 0x2831
leaq 0xd45f(%rip), %rcx      # 0x14334
movl (%rcx), %edx
xorl %ecx, %ecx
testl %edx, %edx
cmovgl %edx, %ecx
cmpl $0x1, %eax
jne 0x6f09
xorl %eax, %eax
cmpq %rax, %rcx
je 0x6f46
movq (%rbx), %rdx
movsd (%rdx,%rax,8), %xmm0
movq 0x10(%r14), %rdx
movsd %xmm0, (%rdx,%rax,8)
movq 0x18(%r14), %rdx
movsd %xmm0, (%rdx,%rax,8)
incq %rax
jmp 0x6ee5
xorl %eax, %eax
cmpq %rax, %rcx
je 0x6f46
movq 0x10(%r14), %rdx
movsd (%rdx,%rax,8), %xmm1
movq (%rbx), %rsi
movsd (%rsi,%rax,8), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x6f31
movsd %xmm0, (%rdx,%rax,8)
movsd (%rsi,%rax,8), %xmm0
movq 0x18(%r14), %rdx
ucomisd (%rdx,%rax,8), %xmm0
jbe 0x6f41
movsd %xmm0, (%rdx,%rax,8)
incq %rax
jmp 0x6f0b
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5254
movq %rbx, %rdi
movq %rax, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x56d5
cmpl $0x2, (%rbx)
jb 0x72c6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5bb9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r12d, %r12d
movq %rsi, -0x30(%rbp)
movq %rbx, %rdi
callq 0x2831
cltq
cmpq %rax, %r12
jge 0x7396
movq (%rbx), %rax
movq (%rax,%r12,8), %r13
callq 0x306c
movq %rax, %r15
xorl %edi, %edi
xorl %esi, %esi
callq 0x3db7
movq %rax, %rdi
callq 0x308a
movq %rax, 0x8(%r15)
incl (%r15)
callq 0x306c
movq 0x8(%r15), %rcx
movq %rax, 0x8(%rcx)
xorl %ebx, %ebx
movq 0x10(%r13), %rdi
callq 0x2831
cltq
cmpq %rax, %rbx
jge 0x7382
movq 0x10(%r13), %rax
movq 0x8(%rax), %rax
movslq (%rax,%rbx,4), %rdi
shlq $0x6, %rdi
addq 0x8(%r14), %rdi
callq 0x3df9
movq %r15, %rdi
movq %rax, %rsi
callq 0x4b9d
cmpl $0x2, (%r15)
jb 0x737d
movq %r15, %rdi
callq 0x3e4d
movq %rax, %r15
incq %rbx
jmp 0x7338
movq 0x38(%r13), %rax
movq %r15, 0x20(%rax)
incq %r12
movq -0x30(%rbp), %rbx
jmp 0x72ef
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x744e
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x743c
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x743c
movq (%r14), %rax
movl (%rax), %ecx
cmpl $0x1, %ecx
je 0x7411
testl %ecx, %ecx
jne 0x73c4
movq 0x10(%r14), %r15
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x2280
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x2280
movq (%r14), %rax
jmp 0x7415
movq 0x10(%r14), %r15
movq 0x8(%rax), %rdi
callq 0x2280
movq (%r14), %rdi
callq 0x2280
movq 0x8(%r14), %rdi
callq 0x73a5
movq %r14, %rdi
callq 0x2280
movq %r15, %r14
jmp 0x73c4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2280
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
leaq 0xc872(%rip), %rax      # 0x14334
movl (%rax), %eax
movq (%rdi), %rcx
xorl %r8d, %r8d
testl %eax, %eax
cmovlel %r8d, %eax
leaq (,%rax,8), %r9
cmpq %r8, %r9
je 0x7af9
movq (%rcx), %r10
movsd (%r10,%r8), %xmm0
movsd %xmm0, 0x8(%rdx,%r8,2)
movsd %xmm0, (%rdx,%r8,2)
addq $0x8, %r8
jmp 0x7ad8
xorl %ecx, %ecx
movabsq $0x1, %r8
cmpq %rax, %rcx
je 0x7b61
movslq (%rsi), %r9
movq %rcx, %rbx
shlq $0x4, %rbx
leaq (%rdx,%rbx), %r10
movq (%rdi), %r11
addq %rdx, %rbx
addq $0x8, %rbx
addq $0x18, %r11
movq %r8, %r14
cmpq %r9, %r14
jge 0x7b5c
movsd (%r10), %xmm1
movq (%r11), %r15
movsd (%r15,%rcx,8), %xmm0
ucomisd %xmm0, %xmm1
movq %r10, %r15
ja 0x7b4e
ucomisd (%rbx), %xmm0
movq %rbx, %r15
jbe 0x7b53
movsd %xmm0, (%r15)
incq %r14
addq $0x18, %r11
jmp 0x7b29
incq %rcx
jmp 0x7b05
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc7af(%rip), %rax      # 0x14334
movl (%rax), %r13d
movl %r13d, %eax
imull %edx, %eax
movslq %eax, %rdi
pushq $0x10
popq %rsi
callq 0x2180
movq %rax, %r15
shll $0x4, %r13d
movq 0xc409(%rip), %rax      # 0x13fb0
movq %rax, (%rsp)
movq 0xc3ee(%rip), %rdx      # 0x13fa0
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %rcx
movl %r13d, %r8d
movq %rdx, %r9
callq 0x2050
leaq 0xc767(%rip), %rax      # 0x14334
movslq (%rax), %rax
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
movq %r15, %rdx
addq $0x8, %rdx
movq %rax, %rsi
shlq $0x4, %rsi
cmpq %rax, %rcx
jge 0x7c51
movq %rcx, %r8
shlq $0x4, %r8
movsd (%r15,%r8), %xmm0
leaq (%r14,%r8), %rdi
movsd %xmm0, (%r14,%r8)
movsd 0x8(%r15,%r8), %xmm1
movsd %xmm1, 0x8(%r14,%r8)
movl %ebx, %r8d
movq %rdx, %r9
subl $0x1, %r8d
jb 0x7c48
movsd -0x8(%r9), %xmm2
ucomisd %xmm2, %xmm0
jbe 0x7c2f
movsd %xmm2, (%rdi)
movapd %xmm2, %xmm0
movsd (%r9), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x7c43
movsd %xmm2, 0x8(%rdi)
movapd %xmm2, %xmm1
addq %rsi, %r9
jmp 0x7c15
incq %rcx
addq $0x10, %rdx
jmp 0x7be5
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
leaq 0xc6c2(%rip), %rax      # 0x14334
movl (%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
testl %edx, %edx
cmovlel %ecx, %edx
shlq $0x4, %rax
cmpq %rdx, %rcx
je 0x7cba
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x7cb5
movsd 0x8(%rsi,%r8), %xmm0
movq (%rdi,%rcx,8), %r9
movsd %xmm0, 0x8(%r9,%r8)
movsd (%rsi,%r8), %xmm0
movsd %xmm0, (%r9,%r8)
addq $0x10, %r8
jmp 0x7c8c
incq %rcx
jmp 0x7c84
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2831
decl %eax
movslq %ebx, %rcx
movq 0x10(%r14), %rdx
xorl %esi, %esi
movsd (%rdx,%rcx,8), %xmm0
cmpl %eax, %esi
jge 0x7d49
movl %esi, %r8d
movl %eax, %edi
movslq %r8d, %r9
decq %r9
movl %r8d, %r10d
movsd 0x8(%rdx,%r9,8), %xmm1
incq %r9
incl %r10d
ucomisd %xmm1, %xmm0
ja 0x7cef
leal -0x1(%r10), %r8d
movslq %edi, %r11
incq %r11
movsd -0x8(%rdx,%r11,8), %xmm2
decq %r11
decl %edi
ucomisd %xmm0, %xmm2
ja 0x7d0c
cmpq %r11, %r9
jle 0x7d27
incl %edi
jmp 0x7d36
movsd %xmm2, (%rdx,%r9,8)
movsd %xmm1, (%rdx,%r11,8)
movl %r10d, %r8d
cmpl %edi, %r8d
jle 0x7ce6
cmpl %ebx, %edi
cmovll %r8d, %esi
cmpl %ebx, %r8d
cmovgl %edi, %eax
jmp 0x7cd8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movl %edx, %r15d
movq %rsi, %r13
movq %rdi, %rbx
pushq $0x30
popq %rdi
callq 0x2320
movq %rax, %r12
pushq $0x2
popq %rsi
movq %rax, %rdi
callq 0x27ac
leaq 0xc5d8(%rip), %rax      # 0x14360
movq (%rax), %rdx
andl $0x0, (%rdx)
movl (%r13), %esi
movq %r12, %rdi
callq 0x283a
movslq (%r13), %rax
movq (%rbx), %rcx
movslq %r15d, %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x7dc6
movq (%rcx), %rdi
movsd (%rdi,%rdx,8), %xmm0
movq 0x10(%r12), %rdi
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
addq $0x18, %rcx
jmp 0x7da6
movq %r12, %rdi
callq 0x2831
cltd
pushq $0x2
popq %r13
idivl %r13d
movq %r12, %rdi
movl %eax, %esi
callq 0x7cbc
leaq -0x38(%rbp), %r15
movsd %xmm0, (%r15)
movq %r12, %rdi
callq 0x2a78
movq %r12, %rdi
callq 0x2280
movq (%r14), %rdi
leaq -0x2c(%rbp), %rbx
movq %rbx, %rsi
callq 0x2250
pushq $0x30
popq %rdi
callq 0x2320
movq %rax, %r12
movq %rax, %rdi
movl %r13d, %esi
callq 0x27ac
movl (%rbx), %esi
leaq 0xc539(%rip), %rax      # 0x14360
movq (%rax), %rdx
movq %r12, %rdi
callq 0x283a
movq 0x10(%r12), %rcx
movq (%r14), %rax
movq %rax, (%rsp)
movq 0xc17b(%rip), %rdx      # 0x13fc0
pushq $0x1
popq %rsi
movq %r15, %rdi
movl %esi, %r8d
movq %rdx, %r9
callq 0x2050
movq %r12, %rdi
callq 0x2831
cltd
idivl %r13d
movq %r12, %rdi
movl %eax, %esi
callq 0x7cbc
movsd %xmm0, (%r15)
movq %r12, %rdi
callq 0x2a78
movq %r12, %rdi
callq 0x2280
movsd (%r15), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/partition.cpp
// Function: get_points_to_send(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, int*, std::vector<double, std::allocator<double>>&, std::vector<int, std::allocator<int>>&, double, int, int, int)
int get_points_to_send(vector< vector< double> >& objects, int* num_points, vector<double>& send_buf, vector<int>& invalid_pos_as, double median, int d, int rank, int partner_rank)
{
	int i, count = 0, j;
	send_buf.reserve((*num_points) * DIMENSION); 
	invalid_pos_as.clear();
	invalid_pos_as.resize(*num_points, 0);

	for(i = 0; i < *num_points; i++)
	{
		if (rank < partner_rank)
		{
			if(objects[i][d] > median)
			{
				invalid_pos_as[i] = 1;
				count++;
				for(j = 0; j < DIMENSION; j++)
					send_buf.push_back(objects[i][j]);
			}
		}
		else
		{
			if(objects[i][d] <= median)
			{
				invalid_pos_as[i] = 1;
				count++;
				for(j = 0; j < DIMENSION; j++)
					send_buf.push_back(objects[i][j]);
			}
		}
	}

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebx
movl %r8d, %r14d
movsd %xmm0, -0x48(%rbp)
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, %r13
movq %rsi, -0x50(%rbp)
movslq (%rsi), %rax
leaq 0xc46c(%rip), %rcx      # 0x14334
movslq (%rcx), %rsi
imulq %rax, %rsi
movq %rdx, %rdi
callq 0x9422
movq (%r12), %rax
cmpq %rax, 0x8(%r12)
je 0x7ee7
movq %rax, 0x8(%r12)
movq -0x50(%rbp), %rax
movslq (%rax), %rsi
leaq -0x5c(%rbp), %rdx
andl $0x0, (%rdx)
movq %r12, %rdi
callq 0x94bc
movslq %r14d, %rax
movq %rax, -0x58(%rbp)
xorl %ecx, %ecx
movl $0x0, -0x2c(%rbp)
movl %ebx, -0x30(%rbp)
movq %r12, -0x40(%rbp)
movq -0x50(%rbp), %rax
movslq (%rax), %rax
cmpq %rax, %rcx
jge 0x7fec
movq %rcx, -0x38(%rbp)
imulq $0x18, %rcx, %r14
movq (%r13), %rax
movq (%rax,%r14), %rax
movq -0x58(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
cmpl 0x10(%rbp), %ebx
jge 0x7f8c
ucomisd -0x48(%rbp), %xmm0
jbe 0x7fe0
movq (%r12), %rax
movq -0x38(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
xorl %r12d, %r12d
xorl %ebx, %ebx
leaq 0xc3cc(%rip), %rax      # 0x14334
movslq (%rax), %rax
cmpq %rax, %rbx
jge 0x7fd6
movq (%r13), %rax
movq (%rax,%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0x94f6
incq %rbx
addq $0x8, %r12
jmp 0x7f61
movsd -0x48(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jb 0x7fe0
movq (%r12), %rax
movq -0x38(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
xorl %r12d, %r12d
xorl %ebx, %ebx
leaq 0xc382(%rip), %rax      # 0x14334
movslq (%rax), %rax
cmpq %rax, %rbx
jge 0x7fd6
movq (%r13), %rax
movq (%rax,%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0x94f6
incq %rbx
addq $0x8, %r12
jmp 0x7fab
incl -0x2c(%rbp)
movl -0x30(%rbp), %ebx
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %rcx
incq %rcx
jmp 0x7f14
movl -0x2c(%rbp), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/partition.cpp
// Function: addPoints(int, int, int, std::vector<double, std::allocator<double>>&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, vectorc*, int*)
bool addPoints(int source, int buf_size, int dims, vector<double>& raw_data, vector< vector<double> >& remote_objects, vectorc* remote_PrIDs, int* remote_number)
{
	int i, j, k, pos, num_points = buf_size / dims;

	if(DIMENSION != dims)
		return false;

	pos = *remote_number;
	*remote_number = *remote_number + num_points;

	remote_objects.resize(*remote_number);

	for(int ll = 0; ll < *remote_number; ll++)
		remote_objects[ll].resize(dims);

	addHelper[0] = -1;
	VECTOR_RESIZE(remote_PrIDs, *remote_number, (void*)addHelper);
	// remote_PrIDs.resize(*remote_number, -1);

	k = 0;
	for(i = 0; i < num_points; i++)
	{
		for(j = 0; j < dims; j++)
			remote_objects[pos][j] = raw_data[k++];

		remote_PrIDs->intItems[pos] = source;

		pos++;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r12d
movl %esi, %eax
cltd
idivl %r12d
leaq 0xbab6(%rip), %rdx      # 0x14334
movl (%rdx), %edx
movl %edx, -0x38(%rbp)
cmpl %r12d, %edx
jne 0x8971
movq %r8, %r14
movl %edi, -0x30(%rbp)
movq %rcx, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movq 0x10(%rbp), %rcx
movslq (%rcx), %rbx
movl %eax, -0x2c(%rbp)
movslq %eax, %rsi
addq %rbx, %rsi
movl %esi, (%rcx)
movq %r8, %rdi
callq 0x92a6
movl %r12d, -0x34(%rbp)
movslq %r12d, %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x10(%rbp), %rax
movslq (%rax), %rax
cmpq %rax, %r15
jge 0x88e4
movq (%r14), %rdi
addq %r13, %rdi
movq %r12, %rsi
callq 0x92e8
incq %r15
addq $0x18, %r13
jmp 0x88c1
leaq 0xba75(%rip), %rax      # 0x14360
movq (%rax), %rdx
orl $-0x1, (%rdx)
movq 0x10(%rbp), %rax
movl (%rax), %esi
movq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x283a
xorl %eax, %eax
movl -0x34(%rbp), %r12d
testl %r12d, %r12d
movl $0x0, %ecx
cmovgl %r12d, %ecx
movl -0x2c(%rbp), %r13d
testl %r13d, %r13d
cmovlel %eax, %r13d
xorl %edx, %edx
movq -0x40(%rbp), %r10
movl -0x30(%rbp), %r11d
cmpl %r13d, %eax
je 0x8971
imulq $0x18, %rbx, %rsi
addq (%r14), %rsi
movslq %edx, %rdx
leaq (,%rdx,8), %r8
addq (%r10), %r8
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x895f
movsd (%r8,%rdi,8), %xmm0
movq (%rsi), %r9
movsd %xmm0, (%r9,%rdi,8)
incq %rdi
jmp 0x8946
movq 0x8(%r15), %rsi
movl %r11d, (%rsi,%rbx,4)
incq %rbx
incl %eax
addq %rdi, %rdx
jmp 0x892a
cmpl %r12d, -0x38(%rbp)
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xb9bc(%rip), %rax      # 0x14360
movq (%rax), %rdx
orl $-0x1, (%rdx)
movq %rsi, %rdi
movl %ecx, %esi
callq 0x283a
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
movq (%r12), %rcx
pushq $-0x1
popq %rdx
xorl %esi, %esi
movl %edx, %edi
cmpq %rsi, %rbx
je 0x89fa
movq 0x8(%r14), %r8
movslq (%r8,%rsi,4), %r8
cmpl %edi, %r8d
cmovnel %eax, %edx
imulq $0x18, %r8, %rdi
movslq %edx, %r9
incl %edx
movq (%rcx,%rdi), %rdi
movl (%rdi,%r9,4), %edi
movq 0x8(%r15), %r9
movl %edi, (%r9,%rsi,4)
incq %rsi
movl %r8d, %edi
jmp 0x89c6
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22d0
movsd %xmm0, -0x60(%rbp)
xorpd %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movapd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x2, %rsi
callq 0xd602
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0xa898
movq %rbx, -0x58(%rbp)
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0xaa9f
movq %rax, 0x8(%r14)
movq -0x50(%rbp), %rax
movl (%rax), %eax
leaq -0x34(%rbp), %r15
testl %eax, %eax
jle 0xab0e
movl %eax, -0x30(%rbp)
movslq %ecx, %rax
movq -0x50(%rbp), %rcx
movl (%rcx,%rax,4), %edx
movl %edx, -0x34(%rbp)
leal 0x2(%rax), %edx
movl 0x4(%rcx,%rax,4), %r12d
movl %edx, -0x2c(%rbp)
movslq %edx, %r13
xorl %ebx, %ebx
testl %r12d, %r12d
cmovlel %ebx, %r12d
shlq $0x2, %r13
negl %r12d
cmpl %ebx, %r12d
je 0xab02
movq %r14, %rdi
movq %r15, %rsi
callq 0x3b0a
movq -0x50(%rbp), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x3b0a
decl %ebx
addq $0x4, %r13
jmp 0xaadb
movl -0x2c(%rbp), %ecx
subl %ebx, %ecx
movl -0x30(%rbp), %eax
decl %eax
jmp 0xaaa9
movq -0x50(%rbp), %rax
cmpq %rax, -0x48(%rbp)
je 0xab1c
movq %rax, -0x48(%rbp)
callq 0x22d0
movq -0x58(%rbp), %rax
subsd -0x60(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
leaq -0x50(%rbp), %rdi
callq 0x9d22
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xab4e
jmp 0xab4e
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x9d22
movq %rbx, %rdi
callq 0x2460
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/clustering.cpp
// Function: get_clusters_sequential(dataHdr*)
struct result* get_clusters_sequential(DataHdr dataList)
{
	int rank, nproc, i;
	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
	int root;
	int clusters = 0;
	int noise = 0;
	int totalcore = 0;

	FILE* debug;
	string currFile("");
	currFile = debugFileName + patch::to_string(rank);
	debug = fopen(currFile.c_str(), "w");
	Data dataroot;
	Data datai;
	for(i = 0; i < dataList->localCnt; i++)
	{
		root = i;
		dataroot = dataList->dataClstElem + root;
		datai = dataroot;

		if(datai->core_tag == TRUE)totalcore++;
		if(datai->ClusterID == 0) noise++;
		
		if(dataroot->parentId == dataroot->id && dataroot->parentProcessId == rank && dataroot->ClusterID==1) // root is a local root
		{
			datai = dataList->dataClstElem + i;
			datai->parentId = root;
			clusters++;
			dataroot->childCount = dataroot->childCount + 1;
		}

		// if(debug!=NULL){
		// 	fprintf(debug,"%lf\t%lf\t%lf\t%d\n",datai->iData[0],datai->iData[1],datai->iData[2],(int)datai->core_tag);
		// }

	}

	struct result* r;
	r = (struct result*)calloc(1, sizeof(struct result));
	r->noise = noise;
	r->clusters = clusters;
	r->corepoints = totalcore;
	
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x6aee(%rip), %rdi      # 0x13fb0
leaq -0x24(%rbp), %r14
movq %r14, %rsi
callq 0x2370
leaq 0x1b38(%rip), %rsi      # 0xf00d
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x20f0
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x934d
leaq 0x6db8(%rip), %rsi      # 0x142b0
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0xd69b
leaq -0x68(%rbp), %r14
leaq -0x88(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x22b0
movq %r15, %rdi
callq 0x2110
leaq -0x48(%rbp), %rdi
callq 0x2110
movq (%r14), %rdi
leaq 0x1ceb(%rip), %rsi      # 0xf224
callq 0x2270
movl 0x4(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
pushq $0x14
popq %rdx
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq %rcx, %rax
je 0xd5ad
movq 0x8(%rbx), %r8
xorl %esi, %esi
cmpl $0x1, 0x14(%r8,%rdx)
movl (%r8,%rdx), %r10d
sete %dil
movl 0x1c(%r8,%rdx), %r9d
cmpl $0x1, %r9d
adcl $0x0, %r12d
cmpl 0x8(%r8,%rdx), %r10d
jne 0xd59e
movl 0x4(%r8,%rdx), %r10d
cmpl -0x24(%rbp), %r10d
jne 0xd59e
cmpl $0x1, %r9d
jne 0xd59e
movl %ecx, (%r8,%rdx)
incl %r15d
incl 0x10(%r8,%rdx)
movb %dil, %sil
addl %esi, %r14d
incq %rcx
addq $0x40, %rdx
jmp 0xd554
pushq $0x1
popq %rdi
pushq $0xc
popq %rsi
callq 0x2180
movq %rax, %rbx
movl %r12d, (%rax)
movl %r15d, 0x4(%rax)
movl %r14d, 0x8(%rax)
leaq -0x68(%rbp), %rdi
callq 0x2110
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2110
jmp 0xd5f0
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2460
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rax)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x7460
movl %eax, %ebx
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movl %eax, %edi
callq 0x2aec
movq %rax, (%r14)
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x2cf8
leaq -0x30(%rbp), %rdi
callq 0x2ea4
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2ea4
movq %rbx, %rdi
callq 0x2460