LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ADAPTLab[P]MuDBSCAN/Data.cpp
// Function: insertDataLstElemRemote(dataHdr*, double*, int, int)
void insertDataLstElemRemote(DataHdr dataHdrInfo, DataPoint iData, int parentId, int remoteIndex)
{

    Data dataClstElem = dataHdrInfo->dataClstElem + dataHdrInfo->uiCnt;
    dataClstElem->id = dataHdrInfo->uiCnt;
    dataClstElem->iData = iData;
    dataHdrInfo->uiCnt++;

    dataClstElem->haloPoint = TRUE;
    dataClstElem->childCount = 0;
    dataClstElem->cid = -1;
    dataClstElem->actualProcessId = parentId;
    dataClstElem->remoteIndex = remoteIndex;

    dataClstElem->parentId = remoteIndex;
    dataClstElem->parentProcessId = parentId;

    dataClstElem->isProcessed = TRUE;
    dataClstElem->core_tag = FALSE;
    dataClstElem->ClusterID = 0;
    dataClstElem->group_id = -1;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/Data.cpp
// Function: populateDataListRemote(dataHdr*, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, vectorc*, vectorc*)
void populateDataListRemote(DataHdr dataList, vector< vector<double> >& remote_objects, vectorc* remote_PrIDs, vectorc* remote_Indices)
{
    
    int i;
    DataPoint iData;
    // if(dataList->uiCnt != dataList->localCnt)
    // {
    //     fprintf(stderr, "Unacceptable state! LocalCnt %d is supposed to be equal to total Count %d here!!\n", dataList->localCnt, dataList->uiCnt);
    //     exit(-1);
    // }

    for(i=0; i<remote_objects.size(); i++)
    {
        iData = (DataPoint) calloc(DIMENSION, sizeof(double));
        // assert(iData != NULL);
        int j;

        for(j=0;j<DIMENSION;j++)
        {
            iData[j] = remote_objects[i][j];
        }
        
        insertDataLstElemRemote(dataList, iData, remote_PrIDs->intItems[i], remote_Indices->intItems[i]);
        vector<double>().swap(remote_objects[i]);
    }
    vector< vector<double> >().swap(remote_objects);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf820
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0xf4f6
leaq 0x293ad(%rip), %rax     # 0x387d4
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x9400
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
leaq 0x2938b(%rip), %rcx     # 0x387d4
cmpl (%rcx), %eax
jge 0xf482
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xf850
movq %rax, %rdi
movslq -0x34(%rbp), %rsi
callq 0xf870
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xf43f
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
callq 0xf310
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x9320
leaq -0x50(%rbp), %rdi
callq 0xf890
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xf850
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0xf8b0
leaq -0x50(%rbp), %rdi
callq 0xf910
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xf3ff
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x9320
leaq -0x68(%rbp), %rdi
callq 0xf970
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xf990
leaq -0x68(%rbp), %rdi
callq 0xf9f0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/Data.cpp
// Function: insertDataLstElemLocal(dataHdr*, double*, int)
void insertDataLstElemLocal(DataHdr dataHdrInfo, DataPoint iData, int rank)
{
    Data dataClstElem = dataHdrInfo->dataClstElem + dataHdrInfo->uiCnt;
    dataClstElem->id = dataHdrInfo->uiCnt; //ID represents local id. ID with respect to the local node
    dataClstElem->iData = iData;
    
    dataHdrInfo->uiCnt++;
    dataHdrInfo->localCnt++;
    
    dataClstElem->haloPoint = FALSE;
    dataClstElem->remoteIndex = -1;
    dataClstElem->actualProcessId = rank;

    dataClstElem->childCount = 0;
    dataClstElem->cid = -1;

    dataClstElem->parentId = dataClstElem->id;
    dataClstElem->parentProcessId = rank;

    dataClstElem->isProcessed = FALSE;
    dataClstElem->core_tag = FALSE;
    dataClstElem->ClusterID = 0;
    dataClstElem->group_id = -1;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/Data.cpp
// Function: populateDataListLocal(dataHdr*, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
void populateDataListLocal(DataHdr dataList, vector< vector< double > >& objects)
{
    int rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    int i;
    DataPoint iData;

    // if(dataList->uiCnt != 0 || dataList->localCnt != 0)
    // {
    //     fprintf(stderr, "Unacceptable state! dataList is supposed to empty here! LSize = %d TSize = %d\n", dataList->uiCnt, dataList->localCnt);
    //     exit(-1);
    // }

    for(i=0;i<objects.size();i++)
    {
        iData = (DataPoint) calloc(DIMENSION, sizeof(double));
        // assert(iData != NULL);
        int j;

        for(j=0;j<DIMENSION;j++)
        {
            iData[j] = objects[i][j];
        }

        insertDataLstElemLocal(dataList, iData, rank);
        vector<double>().swap(objects[i]);
    }
    vector< vector <double> >().swap(objects);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x28981(%rip), %rdi     # 0x37fa8
leaq -0x14(%rbp), %rsi
callq 0x99e0
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf820
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0xf713
leaq 0x29175(%rip), %rax     # 0x387d4
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x9400
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
leaq 0x29153(%rip), %rcx     # 0x387d4
cmpl (%rcx), %eax
jge 0xf6ba
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xf850
movq %rax, %rdi
movslq -0x24(%rbp), %rsi
callq 0xf870
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xf677
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xf530
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x9320
leaq -0x40(%rbp), %rdi
callq 0xf890
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xf850
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0xf8b0
leaq -0x40(%rbp), %rdi
callq 0xf910
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf637
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x9320
leaq -0x58(%rbp), %rdi
callq 0xf970
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xf990
leaq -0x58(%rbp), %rdi
callq 0xf9f0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/Data.cpp
// Function: printData(data*)
void printData(Data dataPoint)
{
    printf("Group %d\t",dataPoint->group_id);
    int iCnt=0;
    for(iCnt = 0; iCnt < DIMENSION; iCnt++)
        printf("%lf ", dataPoint->iData[iCnt] );

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
leaq 0x1c988(%rip), %rdi     # 0x2c0f2
movb $0x0, %al
callq 0x9040
movl $0x0, -0xc(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x2904b(%rip), %rcx     # 0x387d4
cmpl (%rcx), %eax
jge 0xf7b6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x1c958(%rip), %rdi     # 0x2c0fc
movb $0x1, %al
callq 0x9040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf77f
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ADAPTLab[P]MuDBSCAN/Data.cpp
// Function: freeDataList(dataHdr*)
void freeDataList(DataHdr dataList1)
{
    int i;
    for(i=0;i<dataList1->uiCnt;i++)
        free((dataList1->dataClstElem+i)->iData);

    free(dataList1->dataClstElem);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xf804
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x97c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf7d3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x97c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/GList.cpp
// Function: GinitHdrNd()
GHdrNd GinitHdrNd()
{   
	GHdrNd HdrNdLst = (GHdrNd)calloc(1, sizeof(struct GhdrNd));
	// assert(HdrNdLst!=NULL);    

	HdrNdLst->uiCnt = 0;
	HdrNdLst->ptrFirstNd = NULL;
	HdrNdLst->ptrParentNd = NULL;
	
	return HdrNdLst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x18, %esi
callq 0x9400
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/GList.cpp
// Function: GinitLstNd(GtreeNode*)
GLstNd GinitLstNd(GTreeNode tnInfo)
{   
	GLstNd LstNdElem = (GLstNd)calloc(1, sizeof(struct GlstNd));
	// assert(LstNdElem!=NULL);	

	LstNdElem->tnInfo = tnInfo;
	LstNdElem->ptrChildLst = NULL;
	LstNdElem->ptrNextNd = NULL;
	
	return LstNdElem;
		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x9400
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ADAPTLab[P]MuDBSCAN/GList.cpp
// Function: GinsertLstNd(GhdrNd*, GlstNd*)
void GinsertLstNd(GHdrNd HdrNdLst, GLstNd LstNdElem)
{   
	if(LstNdElem == NULL || HdrNdLst == NULL)
		return;
    LstNdElem->ptrNextNd = HdrNdLst->ptrFirstNd;
	HdrNdLst->ptrFirstNd = LstNdElem;
	HdrNdLst->uiCnt++;
	
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1027a
cmpq $0x0, -0x8(%rbp)
jne 0x1027c
jmp 0x102a3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/GList.cpp
// Function: GdeleteLstElem(GhdrNd*, GtreeNode*)
GLstNd GdeleteLstElem(GHdrNd HdrNdLst, GTreeNode tnInfo)
{ if(GisLstEmpty(HdrNdLst))
    return NULL;
  GTreeNode tnInfoTemp = NULL;
  Boolean bIsFound = FALSE;
  GLstNd LstNdTemp = HdrNdLst->ptrFirstNd;
  if(LstNdTemp->tnInfo == tnInfo)
  { 
    	return GdeleteLstFirst(HdrNdLst);
  }

  while(LstNdTemp->ptrNextNd != NULL)
  {   
  	if(LstNdTemp->ptrNextNd->tnInfo == tnInfo)
    {   
      	bIsFound = TRUE;
    	return GdeleteNextNd(HdrNdLst, LstNdTemp);
	}   
    
    LstNdTemp = LstNdTemp->ptrNextNd;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x102b0
cmpl $0x0, %eax
je 0x1031b
movq $0x0, -0x8(%rbp)
jmp 0x103a0
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x10352
movq -0x10(%rbp), %rdi
callq 0x103b0
movq %rax, -0x8(%rbp)
jmp 0x103a0
jmp 0x10354
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x10398
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x1038a
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x10430
movq %rax, -0x8(%rbp)
jmp 0x103a0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x10354
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/GList.cpp
// Function: GdeleteLstFirst(GhdrNd*)
GLstNd GdeleteLstFirst(GHdrNd HdrNdLst)
{
   if(GisLstEmpty(HdrNdLst))
		return NULL;
	GTreeNode tnInfoTemp = NULL;
	GLstNd lstNdTemp = HdrNdLst->ptrFirstNd;

	HdrNdLst->ptrFirstNd = lstNdTemp->ptrNextNd;
	HdrNdLst->uiCnt--;
	lstNdTemp->ptrNextNd = NULL;

		
	return lstNdTemp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x102b0
cmpl $0x0, %eax
je 0x103d4
movq $0x0, -0x8(%rbp)
jmp 0x10417
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/GList.cpp
// Function: GdeleteNextNd(GhdrNd*, GlstNd*)
GLstNd GdeleteNextNd(GHdrNd HdrNdLst, GLstNd LstNdElem)
{
   if(GisLstEmpty(HdrNdLst) || LstNdElem == NULL || LstNdElem->ptrNextNd == NULL)	
		return NULL;

	GLstNd LstNdTemp = LstNdElem->ptrNextNd;
    LstNdElem->ptrNextNd = LstNdTemp->ptrNextNd;
	LstNdTemp->ptrNextNd = NULL;	
	HdrNdLst->uiCnt--;

	return LstNdTemp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x102b0
cmpl $0x0, %eax
jne 0x10460
cmpq $0x0, -0x18(%rbp)
je 0x10460
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1046a
movq $0x0, -0x8(%rbp)
jmp 0x104a5
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ADAPTLab[P]MuDBSCAN/RList.cpp
// Function: RinsertLstNd(RhdrNd*, RlstNd*)
void RinsertLstNd(RHdrNd HdrNdLst, RLstNd LstNdElem)
{   
    if(LstNdElem == NULL || HdrNdLst == NULL)
        return;
    LstNdElem->ptrNextNd = HdrNdLst->ptrFirstNd;
    HdrNdLst->ptrFirstNd = LstNdElem;
    HdrNdLst->uiCnt++;
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x105aa
cmpq $0x0, -0x8(%rbp)
jne 0x105ac
jmp 0x105d3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/RList.cpp
// Function: RisLstEmpty(RhdrNd*)
Boolean RisLstEmpty(RHdrNd HdrNdLst)
{   
    if(HdrNdLst!=NULL)
    {
        if(HdrNdLst->ptrFirstNd == NULL)
        return TRUE;

        else if(HdrNdLst->uiCnt == 0)
            return TRUE;

        else
            return FALSE;
    
    }
    
    return TRUE;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1061e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x10603
movl $0x1, -0x4(%rbp)
jmp 0x10625
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x10615
movl $0x1, -0x4(%rbp)
jmp 0x10625
movl $0x0, -0x4(%rbp)
jmp 0x10625
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/RList.cpp
// Function: RdeleteLstElem(RhdrNd*, RtreeNode*)
RLstNd RdeleteLstElem(RHdrNd HdrNdLst, RTreeNode tnInfo)
{ 

  if(RisLstEmpty(HdrNdLst))
    return NULL;
  RTreeNode tnInfoTemp = NULL;
  Boolean bIsFound = FALSE;
  RLstNd LstNdTemp = HdrNdLst->ptrFirstNd;
  if(LstNdTemp->tnInfo == tnInfo)
    { return RdeleteLstFirst(HdrNdLst);  }

  while(LstNdTemp->ptrNextNd != NULL)
    {   if(LstNdTemp->ptrNextNd->tnInfo == tnInfo)
        {   bIsFound = TRUE;
        
      return RdeleteNextNd(HdrNdLst, LstNdTemp);
    }   
    LstNdTemp = LstNdTemp->ptrNextNd;
  }
  
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x105e0
cmpl $0x0, %eax
je 0x1065b
movq $0x0, -0x8(%rbp)
jmp 0x106e0
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x10692
movq -0x10(%rbp), %rdi
callq 0x106f0
movq %rax, -0x8(%rbp)
jmp 0x106e0
jmp 0x10694
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x106d8
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x106ca
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x10770
movq %rax, -0x8(%rbp)
jmp 0x106e0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x10694
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/RList.cpp
// Function: RdeleteLstFirst(RhdrNd*)
RLstNd RdeleteLstFirst(RHdrNd HdrNdLst)
{   
    if(RisLstEmpty(HdrNdLst))
        return NULL;
    RTreeNode tnInfoTemp = NULL;
    RLstNd lstNdTemp = HdrNdLst->ptrFirstNd;

    HdrNdLst->ptrFirstNd = lstNdTemp->ptrNextNd;
    HdrNdLst->uiCnt--;
    lstNdTemp->ptrNextNd = NULL;

        
    return lstNdTemp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x105e0
cmpl $0x0, %eax
je 0x10714
movq $0x0, -0x8(%rbp)
jmp 0x10757
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/RList.cpp
// Function: RdeleteNextNd(RhdrNd*, RlstNd*)
RLstNd RdeleteNextNd(RHdrNd HdrNdLst, RLstNd LstNdElem)
{   
    if(RisLstEmpty(HdrNdLst) || LstNdElem == NULL || LstNdElem->ptrNextNd == NULL)  
        return NULL;

    RLstNd LstNdTemp = LstNdElem->ptrNextNd;
    LstNdElem->ptrNextNd = LstNdTemp->ptrNextNd;
    LstNdTemp->ptrNextNd = NULL;    
    HdrNdLst->uiCnt--;

    return LstNdTemp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x105e0
cmpl $0x0, %eax
jne 0x107a0
cmpq $0x0, -0x18(%rbp)
je 0x107a0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x107aa
movq $0x0, -0x8(%rbp)
jmp 0x107e5
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ADAPTLab[P]MuDBSCAN/RList.cpp
// Function: RinitNbHdr()
RNbHdr RinitNbHdr()
{
    RNbHdr nbHdrInfo = (RNbHdr)calloc(1, sizeof(struct RnbHdr));
    if(nbHdrInfo == NULL)
        return NULL;

    nbHdrInfo->nbhCnt = 0;
    nbHdrInfo->nbFirst =NULL;
    nbHdrInfo->nbLast = NULL;

    return nbHdrInfo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x18, %esi
callq 0x9400
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1081c
movq $0x0, -0x8(%rbp)
jmp 0x10846
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: ADAPTLab[P]MuDBSCAN/MuC.cpp
// Function: printGroup(group*, _IO_FILE*)
void printGroup(Group g, FILE* f)
{
    fprintf(f, "ID: %d\tTotalPoints: %d\tInnerPoints: %d\tCorepoints: %d\n", g->id, g->total_count, g->inner_count, VECTOR_TOTAL(g->corepoints));
    fprintf(f, "ID: %d\tTotalPoints: %p\tInnerPoints: %p\tCorepoints: %p\n", g->id, g->total_points, g->inner_points, g->corepoints);
    fprintf(f, "ID: %d\tReachableGroups: %p\tBCell: %p\t\n", g->id, g->reachable_groups, g->bcell);

    fflush(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0xa2b0
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl %eax, %r9d
leaq 0x1a9e7(%rip), %rsi     # 0x2c101
movb $0x0, %al
callq 0x9a30
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x58(%rax), %r9
leaq 0x1a9ee(%rip), %rsi     # 0x2c138
movb $0x0, %al
callq 0x9a30
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %r8
leaq 0x1a9fd(%rip), %rsi     # 0x2c16f
movb $0x0, %al
callq 0x9a30
movq -0x10(%rbp), %rdi
callq 0x97a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/MuC.cpp
// Function: initGroup(data*)
Group initGroup(Data datapoint)
{
    noOfGroups++;
    Group newGroup = (Group)calloc(1, sizeof(struct group)); 
    // assert(newGroup != NULL);

    newGroup->type = NONE;
    newGroup->id = GROUPID++;
    newGroup->bcell = NULL;
    newGroup->master_id = datapoint->id;
    newGroup->threshold = 0;

    newGroup->reachable_groups = NULL;
    
    newGroup->master = datapoint->iData;

    newGroup->inner_count = 0;
    newGroup->total_count = 0;

    newGroup->total_points = (vectorc*)malloc(sizeof(struct vectorc));
    // assert(newGroup->total_points != NULL);
    VECTOR_INIT(newGroup->total_points, INTEGER);

    newGroup->inner_points = (vectorc*)malloc(sizeof(struct vectorc));
    // assert(newGroup->inner_points != NULL);
    VECTOR_INIT(newGroup->inner_points, INTEGER);

    newGroup->corepoints = (vectorc*)malloc(sizeof(struct vectorc));
    // assert(newGroup->corepoints != NULL);
    VECTOR_INIT(newGroup->corepoints, INTEGER);

    newGroup->reachable_groups = (vectorc*)malloc(sizeof(struct vectorc));
    // assert(newGroup->reachable_groups != NULL);
    VECTOR_INIT(newGroup->reachable_groups, INTEGER);
    
    return newGroup;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x27085(%rip), %rax     # 0x38828
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
movl $0x1, %edi
movl $0x60, %esi
callq 0x9400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
leaq 0x27026(%rip), %rax     # 0x387f4
movl (%rax), %ecx
movl %ecx, %edx
incl %edx
movl %edx, (%rax)
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
fldz
fstpt 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movl $0x30, %edi
callq 0x9910
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
callq 0xa170
movl $0x30, %edi
callq 0x9910
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0xa170
movl $0x30, %edi
callq 0x9910
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
xorl %esi, %esi
callq 0xa170
movl $0x30, %edi
callq 0x9910
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
xorl %esi, %esi
callq 0xa170
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/MuC.cpp
// Function: initBCell(region*)
BCell initBCell(Region rectTemp)
{
    BCell newBCell = (struct bcell*) calloc(1, sizeof(struct bcell));
    // assert(newBCell != NULL);

    newBCell->minOriginalBoundary = (double*)calloc(DIMENSION, sizeof(double));
    // assert(newBCell->minOriginalBoundary != NULL);

    newBCell->maxOriginalBoundary = (double*)calloc(DIMENSION, sizeof(double));
    // assert(newBCell->maxOriginalBoundary != NULL);

    newBCell->minActualBoundary = (double*)calloc(DIMENSION, sizeof(double));
    // assert(newBCell->minActualBoundary != NULL);

    newBCell->maxActualBoundary = (double*)calloc(DIMENSION, sizeof(double));
    // assert(newBCell->maxActualBoundary != NULL);

    newBCell->id= BCELLID++;
    newBCell->auxCellRTree = NULL;
    int i =0;
    for(i = 0; i < DIMENSION; i++)
    {
        newBCell->minOriginalBoundary[i] = rectTemp->iBottomLeft[i];
        newBCell->maxOriginalBoundary[i] = rectTemp->iTopRight[i];
    }

    return newBCell;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x9400
movq %rax, -0x10(%rbp)
leaq 0x26ede(%rip), %rax     # 0x387d4
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x9400
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
leaq 0x26ec0(%rip), %rax     # 0x387d4
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x9400
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x26ea1(%rip), %rax     # 0x387d4
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x9400
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0x26e82(%rip), %rax     # 0x387d4
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x9400
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq 0x26e87(%rip), %rax     # 0x387f8
movl (%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
leaq 0x26e79(%rip), %rax     # 0x387f8
movl %edx, (%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x26e28(%rip), %rcx     # 0x387d4
cmpl (%rcx), %eax
jge 0x119fd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x119a2
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/MuC.cpp
// Function: freeGroup(group*)
void freeGroup(Group group)
{       
    free(group->bcell->minOriginalBoundary);
    free(group->bcell->maxOriginalBoundary);
    free(group->bcell->minActualBoundary);
    free(group->bcell->maxActualBoundary);
    freeRTree(group->bcell->auxCellRTree);
    free(group->bcell);

    free(group);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rdi
callq 0x97c0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x97c0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x97c0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x97c0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x14520
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x97c0
movq -0x8(%rbp), %rdi
callq 0x97c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: RinitRgnRect(double*, double*)
Region RinitRgnRect(Dimension iBottomLeft, Dimension iTopRight)
{   
	Region rgnRect = (Region)calloc(1, sizeof(struct region));
	// assert(rgnRect != NULL);
    if(rgnRect == NULL)
		return NULL;
		
    if(iBottomLeft != NULL)
		rgnRect->iBottomLeft = iBottomLeft;
	else
		rgnRect->iBottomLeft = (double*)calloc(DIMENSION, sizeof(double));
		// assert(rgnRect->iBottomLeft != NULL);

	if(rgnRect->iBottomLeft == NULL)
    {   
    	free(rgnRect);
		return NULL;
    }

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

	if(rgnRect->iTopRight == NULL)
    {   
    	if(rgnRect->iBottomLeft == NULL);
		free(rgnRect);
		return NULL;
	}

	return rgnRect;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x9400
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12347
movq $0x0, -0x8(%rbp)
jmp 0x123fc
cmpq $0x0, -0x10(%rbp)
je 0x1235b
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x12379
leaq 0x26472(%rip), %rax     # 0x387d4
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x9400
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x12396
movq -0x20(%rbp), %rdi
callq 0x97c0
movq $0x0, -0x8(%rbp)
jmp 0x123fc
cmpq $0x0, -0x18(%rbp)
je 0x123ab
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x123ca
leaq 0x26422(%rip), %rax     # 0x387d4
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x9400
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x123f4
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x123e1
jmp 0x123e1
movq -0x20(%rbp), %rdi
callq 0x97c0
movq $0x0, -0x8(%rbp)
jmp 0x123fc
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: RsetRect(RlstNd*, RtreeNode*)
void RsetRect(RLstNd lstNd, RTreeNode tnInfo)
{
    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] = tnInfo->tdInfo->dataClstElem->iData[iCnt];
			lstNd->tnInfo->tdInfo->rgnRect->iTopRight[iCnt] = tnInfo->tdInfo->dataClstElem->iData[iCnt];
		}
		break;
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x12443
jmp 0x12432
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x124cc
jmp 0x12553
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x26380(%rip), %rcx     # 0x387d4
cmpl (%rcx), %eax
jge 0x124c7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1244a
jmp 0x12553
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x262f7(%rip), %rcx     # 0x387d4
cmpl (%rcx), %eax
jge 0x12551
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x124d3
jmp 0x12553
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: RinitIntNd(double*, double*)
RTreeNode RinitIntNd(Dimension iBottomLeft, Dimension iTopRight)
{
	Region rgnRect = RinitRgnRect(iBottomLeft, iTopRight);
	// assert(rgnRect != NULL);

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

	if(tdInfo == NULL)
		return NULL;

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

	if(tnInfo == NULL)
		return NULL;

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

	return tnInfo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12310
movq %rax, -0x20(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x9400
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x125a5
movq $0x0, -0x8(%rbp)
jmp 0x125fe
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0x9400
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x125e0
movq $0x0, -0x8(%rbp)
jmp 0x125fe
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: RinitExtNd(data*)
RTreeNode RinitExtNd(Data dataClstElem)
{  
   if(dataClstElem == NULL)
		return NULL;

	RTreeNode tnInfo = (RTreeNode)calloc(1, sizeof(*tnInfo));
	// assert(tnInfo!= NULL);

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

	tdInfo->dataClstElem = dataClstElem;
	tdInfo->rgnRect = NULL;

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

	return tnInfo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1262d
movq $0x0, -0x8(%rbp)
jmp 0x12688
movl $0x1, %edi
movl $0x10, %esi
callq 0x9400
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x9400
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: Rarea(region*)
double Rarea(Region rgnRect)
{
    if(rgnRect == NULL)
		return 0;
    double dArea = 1;
	int iCnt = 0;
	for(iCnt = 0; iCnt < DIMENSION; iCnt++)
		dArea = dArea * (rgnRect->iTopRight[iCnt] - rgnRect->iBottomLeft[iCnt]);
	return dArea;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12c59
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x12cc6
movsd 0x19557(%rip), %xmm0    # 0x2c1b8
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x25b56(%rip), %rcx     # 0x387d4
cmpl (%rcx), %eax
jge 0x12cbc
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12c74
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: RinsertTree(RhdrNd*, RtreeNode*)
Boolean RinsertTree(RHdrNd hdrNdTree, RTreeNode tnInfo)
{
	int iCnt = 0;

	if(hdrNdTree->ptrFirstNd == NULL || hdrNdTree->ptrFirstNd->tnInfo->ndType == EXTNODE)
    {   

		
		RinsertLstElem(hdrNdTree, tnInfo);

		
		return(hdrNdTree->uiCnt > RMAXENTRIES) ? TRUE : FALSE;
    }

	if(hdrNdTree->ptrFirstNd->ptrChildLst->uiCnt == 0)
		RsetRect(hdrNdTree->ptrFirstNd, tnInfo);


	RLstNd lstNdTemp = RpickChild(hdrNdTree, tnInfo);

	if(RinsertTree(lstNdTemp->ptrChildLst, tnInfo))
	{

        RsplitNode(lstNdTemp);

	    hdrNdTree->uiCnt++;
	    return (hdrNdTree->uiCnt > RMAXENTRIES) ? TRUE : FALSE;
	}


	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x13f82
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0x13fb2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10550
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0x24850(%rip), %rax     # 0x387ec
movl (%rax), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmoval %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x14036
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
jne 0x13fd4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x12410
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12cd0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13f50
cmpl $0x0, %eax
je 0x1402f
movq -0x28(%rbp), %rdi
callq 0x13920
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0x247d0(%rip), %rax     # 0x387ec
movl (%rax), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmoval %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x14036
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: RbuildRTree(dataHdr*)
RHdrNd RbuildRTree(DataHdr dataHdrLst)
{
	RHdrNd hdrNdTree = RinitHdrNd();
	hdrNdTree->ptrFirstNd = RinitLstNd(RinitIntNd(NULL, NULL));
	hdrNdTree->uiCnt++;
	hdrNdTree->ptrFirstNd->ptrChildLst = RinitHdrNd();

	int cnt = 0,i;
	for(i=0;i<dataHdrLst->uiCnt;i++)
	{
		RinsertTree(hdrNdTree, RinitExtNd((dataHdrLst->dataClstElem)+i));
		if(hdrNdTree->uiCnt > 1)
			hdrNdTree = RcreateRoot(hdrNdTree);
	}

	return	hdrNdTree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x104b0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x12560
movq %rax, %rdi
callq 0x10500
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
callq 0x104b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x140fb
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x18(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x12610
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x13f50
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jbe 0x140ee
movq -0x10(%rbp), %rdi
callq 0x126a0
movq %rax, -0x10(%rbp)
jmp 0x140f0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x140a1
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: RfindDist(double*, double*)
double RfindDist(DataPoint iDataOne, DataPoint iDataTwo)
{   
	double dDist = 0;
	int iCnt = 0;
	int k=0;
	for(iCnt = 0; iCnt < DIMENSION; iCnt++)
	{    
		dDist = dDist + pow(iDataOne[iCnt] - iDataTwo[iCnt], 2);
	}

	return sqrt(dDist);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x244bd(%rip), %rcx     # 0x387d4
cmpl (%rcx), %eax
jge 0x14365
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movl $0x2, %edi
callq 0x148c0
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1430d
movsd -0x18(%rbp), %xmm0
callq 0x94f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: RisContains(region*, double*)
Boolean RisContains(Region rgnRect, DataPoint iData)
{
	int iCnt = 0;
	Boolean bIsContains = TRUE;
	for(iCnt = 0; iCnt < DIMENSION; iCnt++)
    {   
    	if((rgnRect->iBottomLeft[iCnt] > iData[iCnt]) || (rgnRect->iTopRight[iCnt] < iData[iCnt]))
        {   
        	bIsContains = FALSE;
			break;
		}
	}
	return bIsContains;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x24429(%rip), %rcx     # 0x387d4
cmpl (%rcx), %eax
jge 0x14408
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
ja 0x143f2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x143fb
movl $0x0, -0x18(%rbp)
jmp 0x14408
jmp 0x143fd
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x143a1
movl -0x18(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x243a0(%rip), %rcx     # 0x387d4
cmpl (%rcx), %eax
jge 0x1449c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
ja 0x14486
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1448f
movl $0x0, -0x4(%rbp)
jmp 0x144a3
jmp 0x14491
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1442a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: RappendRTree(RhdrNd*, dataHdr*)
void RappendRTree(RHdrNd hdrNdTree, DataHdr dataHdrLst)
{
	int cnt = 0,i;
    for(i=0;i<dataHdrLst->uiCnt;i++)
	{
		RinsertTree(hdrNdTree, RinitExtNd(dataHdrLst->dataClstElem+i));
	}

	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x14510
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x18(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x12610
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x13f50
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x144ce
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)