LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regexstate.cpp
// Function: RegExState::operator=(RegExState const&)
RegExState& RegExState::operator=(const RegExState& other) { 
	this->m_Transition	= other.m_Transition; 
	this->m_nStateID	= other.m_nStateID;
	this->m_NFAStates	= other.m_NFAStates;
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x97b4
movl 0x68(%rbx), %eax
movl %eax, 0x68(%r14)
addq $0x8, %rbx
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x7d44
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regexstate.cpp
// Function: RegExState::GetTransition(char, std::vector<RegExState*, std::allocator<RegExState*>>&)
void RegExState::GetTransition(char inputCh, Table &States) {
	States.clear();
	std::multimap<char, RegExState*>::iterator iter;
	for(iter = m_Transition.lower_bound(inputCh); iter != m_Transition.upper_bound(inputCh); ++iter) {
		RegExState *pState = iter->second;
		States.push_back(pState);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x9572
movq %rax, 0x8(%rbx)
movq 0x48(%r14), %rax
leaq 0x40(%r14), %r13
movq %r13, %r15
testq %rax, %rax
je 0x959f
movq %rax, %rcx
movq %r13, %r15
xorl %edx, %edx
cmpb %bpl, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %r15
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x9588
movq %rsp, %r12
movq %r13, %rcx
testq %rax, %rax
je 0x95c4
movq %r13, %rcx
xorl %edx, %edx
cmpb %bpl, 0x20(%rax)
setle %dl
cmovgq %rax, %rcx
movq 0x10(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x95ad
cmpq %rcx, %r15
je 0x9601
movq 0x28(%r15), %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x95e5
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x95f0
movq %rbx, %rdi
movq %r12, %rdx
callq 0x8bf2
movq %r15, %rdi
callq 0x20d0
movq %rax, %r15
movq 0x48(%r14), %rax
jmp 0x95a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regexstate.cpp
// Function: RegExState::IsDeadEnd()
bool RegExState::IsDeadEnd() {
	if(m_bAcceptingState)
		return false;
	if(m_Transition.empty())
		return true;
	std::multimap<char, RegExState*>::iterator iter;
	for(iter=m_Transition.begin(); iter!=m_Transition.end(); ++iter){
		RegExState *toState = iter->second;
		if(toState != this)
			return false;
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x0, 0x6c(%rdi)
je 0x9625
xorl %ebx, %ebx
jmp 0x9651
movq %rdi, %r14
movb $0x1, %bl
cmpq $0x0, 0x60(%rdi)
je 0x9651
movq 0x50(%r14), %rax
leaq 0x40(%r14), %r15
cmpq %r15, %rax
je 0x9651
cmpq %r14, 0x28(%rax)
sete %bl
jne 0x9651
movq %rax, %rdi
callq 0x20d0
jmp 0x9639
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regexstate.cpp
// Function: RegExState::operator==(RegExState const&)
bool RegExState::operator==(const RegExState& other) {
	if(m_NFAStates.empty())
		return(m_nStateID == other.m_nStateID);
	else 
		return(m_NFAStates == other.m_NFAStates);
}

// Assembly:
movq %rdi, %rax
movq 0x30(%rdi), %rcx
testq %rcx, %rcx
je 0x9680
cmpq 0x30(%rsi), %rcx
jne 0x968a
movq 0x20(%rax), %rdi
addq $0x10, %rax
movq 0x20(%rsi), %rdx
movq %rax, %rsi
jmp 0x92a6
movl 0x68(%rax), %eax
cmpl 0x68(%rsi), %eax
sete %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regexstate.cpp
// Function: RegExState::getStringID[abi:cxx11]()
std::string RegExState::getStringID(){
	std::string result;
	std::stringstream out;
	//if(m_bAcceptingState){
	//	out << "{" << m_nStateID << "}";
	//} else {
		out << m_nStateID;
	//}
	return out.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x28(%rsp), %rdi
callq 0x20e0
leaq 0x38(%rsp), %rdi
movl 0x68(%r14), %esi
callq 0x2240
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x2210
movq 0x48df(%rip), %rsi      # 0xdfc0
leaq 0x28(%rsp), %rdi
callq 0x2100
leaq 0xa8(%rsp), %rdi
callq 0x2060
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x970f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x9745
movq %rax, %rbx
movq 0x4892(%rip), %rsi      # 0xdfc0
leaq 0x28(%rsp), %rdi
callq 0x2100
leaq 0xa8(%rsp), %rdi
callq 0x2060
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x975c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/vectorc.cpp
// Function: vector_add(vectorc*, void*)
void vector_add(vectorc* v, void* item)
{
    int item1;
    double d;
    Group g;
    if(v->capacity == 0)
    {
        VECTOR_INIT(v, v->type);
    }
    if (v->capacity == v->total)
        vector_resize_internal(v, v->capacity*2);
    
    switch(v->type)
    {
        case INTEGER:
            item1 = *((int*)item);
            v->intItems[v->total++] = item1;
            break;

        case DOUBLE:
            d = *((double*)item);
            v->doubleItems[v->total++] = d;
            break;

        case GROUP:
            g = ((Group)item);
            v->groupItems[v->total++] = g;
            break;

        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rdi), %esi
testl %esi, %esi
jne 0x3c42
movl 0x28(%rbx), %esi
movq %rbx, %rdi
callq 0x39bc
movl 0x20(%rbx), %esi
cmpl 0x24(%rbx), %esi
jne 0x3c51
addl %esi, %esi
movq %rbx, %rdi
callq 0x3b7f
movl 0x28(%rbx), %eax
cmpl $0x2, %eax
je 0x3c8b
cmpl $0x1, %eax
je 0x3c78
testl %eax, %eax
jne 0x3ca3
movl (%r14), %eax
movq 0x8(%rbx), %rcx
movslq 0x24(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x24(%rbx)
movl %eax, (%rcx,%rdx,4)
jmp 0x3ca3
movq (%rbx), %rax
movslq 0x24(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movq %r14, (%rax,%rcx,8)
jmp 0x3ca3
movsd (%r14), %xmm0
movq 0x10(%rbx), %rax
movslq 0x24(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movsd %xmm0, (%rax,%rcx,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq (%rsi), %r14
movq %rsi, -0x30(%rbp)
movq 0x8(%rsi), %r15
cmpq %r14, %r15
je 0x3f0d
movq %rdi, %r12
xorl %ebx, %ebx
leaq 0x13551(%rip), %rax     # 0x17364
movslq (%rax), %r13
movl $0x8, %esi
movq %r13, %rdi
callq 0x31b0
leaq (%rbx,%rbx,2), %rcx
movq (%r14,%rcx,8), %rdi
testq %r13, %r13
jle 0x3e44
xorl %edx, %edx
movsd (%rdi,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r13
jne 0x3e32
movq -0x38(%rbp), %rdx
movq 0x8(%rdx), %rdx
movl (%rdx,%rbx,4), %edx
movq -0x40(%rbp), %rsi
movq 0x8(%rsi), %rsi
movl (%rsi,%rbx,4), %esi
movq 0x8(%r12), %r8
movslq (%r12), %r9
movq %r9, %r10
shlq $0x6, %r10
movl %r9d, 0x1c(%r8,%r10)
movq %rax, (%r8,%r10)
leal 0x1(%r9), %eax
movl %eax, (%r12)
movl $0x1, 0x8(%r8,%r10)
movl $0xffffffff, 0x38(%r8,%r10) # imm = 0xFFFFFFFF
movl %edx, 0xc(%r8,%r10)
movl %esi, 0x10(%r8,%r10)
movl %esi, 0x14(%r8,%r10)
movl %edx, 0x18(%r8,%r10)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x28(%r8,%r10)
movl $0x0, 0x30(%r8,%r10)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x20(%r8,%r10)
xorps %xmm0, %xmm0
movups %xmm0, (%r14,%rcx,8)
movq $0x0, 0x10(%r14,%rcx,8)
testq %rdi, %rdi
je 0x3ee9
callq 0x3270
movq -0x30(%rbp), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
incq %rbx
movq %r15, %rax
subq %r14, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rbx, %rax
ja 0x3e0c
leaq -0x58(%rbp), %rdi
movq %r14, (%rdi)
movq %r15, 0x8(%rdi)
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
callq 0x41b4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x12fe2(%rip), %rdi     # 0x16fa8
leaq -0x34(%rbp), %rsi
callq 0x33e0
movq (%rbx), %r12
movq %rbx, -0x40(%rbp)
movq 0x8(%rbx), %rax
movq %rax, -0x30(%rbp)
cmpq %r12, %rax
je 0x40d2
xorl %ebx, %ebx
xorl %r13d, %r13d
leaq 0x13371(%rip), %rax     # 0x17364
movslq (%rax), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x31b0
leaq (,%r13,2), %rcx
addq %r13, %rcx
movq (%r12,%rcx,8), %rdi
testq %r15, %r15
jle 0x402b
xorl %edx, %edx
movsd (%rdi,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r15
jne 0x4019
movl -0x34(%rbp), %edx
movq 0x8(%r14), %rsi
movslq (%r14), %r8
movq %r8, %r9
shlq $0x6, %r9
movl %r8d, 0x1c(%rsi,%r9)
movq %rax, (%rsi,%r9)
leal 0x1(%r8), %eax
movl %eax, (%r14)
incl 0x4(%r14)
movl %ebx, 0x8(%rsi,%r9)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x10(%rsi,%r9)
movl %edx, 0xc(%rsi,%r9)
movl %eax, 0x38(%rsi,%r9)
movl %r8d, 0x14(%rsi,%r9)
movl %edx, 0x18(%rsi,%r9)
movq %rbx, 0x28(%rsi,%r9)
movl %ebx, 0x30(%rsi,%r9)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x20(%rsi,%r9)
movq %rbx, 0x10(%r12,%rcx,8)
xorps %xmm0, %xmm0
movups %xmm0, (%r12,%rcx,8)
testq %rdi, %rdi
je 0x40ad
callq 0x3270
movq -0x40(%rbp), %rax
movq (%rax), %r12
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
incq %r13
movq -0x30(%rbp), %rax
subq %r12, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %r13, %rax
ja 0x3fec
leaq -0x58(%rbp), %rdi
movq %r12, (%rdi)
movq -0x30(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x40(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
callq 0x41b4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %esi
leaq 0xdef9(%rip), %rdi      # 0x12020
xorl %eax, %eax
callq 0x3050
leaq 0x1322f(%rip), %r15     # 0x17364
cmpl $0x0, (%r15)
jle 0x4163
xorl %r12d, %r12d
leaq 0xdee5(%rip), %r14      # 0x1202a
movq (%rbx), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x3050
incq %r12
movslq (%r15), %rax
cmpq %rax, %r12
jl 0x4145
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x41a0
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x3310
incq %r15
movslq (%rbx), %rax
addq $0x40, %r14
cmpq %rax, %r15
jl 0x4184
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x4297
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsi)
movq %rsi, 0x8(%rdi)
incl (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x440b
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsi)
movq %rsi, 0x8(%rdi)
incl (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/RList.cpp
// Function: RdeleteLstElem(RhdrNd*, RtreeNode*)
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:
testq %rdi, %rdi
je 0x4470
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4470
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x4470
pushq %rbp
movq %rsp, %rbp
cmpq %rsi, (%rax)
je 0x4473
movq %rax, %rdx
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x4489
cmpq %rsi, (%rax)
jne 0x4449
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rdx)
movq $0x0, 0x10(%rax)
decl %ecx
movl %ecx, (%rdi)
jmp 0x448b
xorl %eax, %eax
retq
movq 0x10(%rax), %rdx
movq %rdx, 0x8(%rdi)
decl %ecx
movl %ecx, (%rdi)
movq $0x0, 0x10(%rax)
jmp 0x448b
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x1c(%rdi), %r15d
movl (%rdi), %r12d
movl 0x18(%rdi), %r13d
movq 0x58(%rdi), %rdi
callq 0x3a4d
leaq 0xd267(%rip), %rsi      # 0x1202f
movq %rbx, %rdi
movl %r12d, %edx
movl %r15d, %ecx
movl %r13d, %r8d
movl %eax, %r9d
xorl %eax, %eax
callq 0x3400
movl (%r14), %edx
movq 0x10(%r14), %rcx
movq 0x8(%r14), %r8
movq 0x58(%r14), %r9
leaq 0xd272(%rip), %rsi      # 0x12066
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3400
movl (%r14), %edx
movq 0x50(%r14), %rcx
movq 0x38(%r14), %r8
leaq 0xd28d(%rip), %rsi      # 0x1209d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3400
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x12577(%rip), %rax     # 0x173b8
incl (%rax)
movl $0x1, %edi
movl $0x60, %esi
callq 0x31b0
movq %rax, %rbx
leaq 0x12528(%rip), %rax     # 0x17384
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movl %ecx, (%rbx)
movl 0x1c(%r14), %eax
movl %eax, 0x30(%rbx)
movq (%r14), %rax
movq %rax, 0x28(%rbx)
movl $0x30, %edi
callq 0x33a0
movq %rax, 0x10(%rbx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x39bc
movl $0x30, %edi
callq 0x33a0
movq %rax, 0x8(%rbx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x39bc
movl $0x30, %edi
callq 0x33a0
movq %rax, 0x58(%rbx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x39bc
movl $0x30, %edi
callq 0x33a0
movq %rax, 0x50(%rbx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x39bc
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x31b0
movq %rax, %rbx
leaq 0x1245f(%rip), %rax     # 0x17364
movslq (%rax), %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, (%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x31b0
movq %rax, %r13
movq %rax, 0x8(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x31b0
movq %rax, 0x10(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x31b0
movq %rax, 0x18(%rbx)
leaq 0x12430(%rip), %rax     # 0x17388
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movl %ecx, 0x28(%rbx)
testq %r14, %r14
jle 0x4f8f
movq (%r15), %rax
movq 0x8(%r15), %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%r12,%rdx,8)
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%r13,%rdx,8)
incq %rdx
cmpq %rdx, %r14
jne 0x4f70
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/MuC.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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq (%rax), %rdi
callq 0x3310
movq 0x38(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3310
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x3310
movq 0x38(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x3310
movq 0x38(%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x663d
movq 0x38(%rbx), %rdi
callq 0x3310
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
testq %rax, %rax
je 0x51b9
movq %rax, %rbx
testq %r15, %r15
je 0x516d
movq %r15, (%rbx)
jmp 0x5189
leaq 0x121f0(%rip), %rax     # 0x17364
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x31b0
movq %rax, (%rbx)
testq %rax, %rax
je 0x51b1
testq %r14, %r14
je 0x5194
movq %r14, 0x8(%rbx)
jmp 0x51bb
leaq 0x121c9(%rip), %rax     # 0x17364
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x31b0
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x51bb
movq %rbx, %rdi
callq 0x3310
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl (%rsi), %eax
testl %eax, %eax
je 0x5226
cmpl $0x1, %eax
jne 0x5277
leaq 0x12181(%rip), %rax     # 0x17364
movslq (%rax), %rax
testq %rax, %rax
jle 0x5277
movq 0x8(%rsi), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
movq (%rdi), %rdx
movq 0x8(%rdx), %rdx
movq (%rdx), %rsi
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
xorl %edi, %edi
movsd (%rcx,%rdi,8), %xmm0
movsd %xmm0, (%rdx,%rdi,8)
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x520d
jmp 0x5277
leaq 0x12137(%rip), %rax     # 0x17364
movslq (%rax), %rax
testq %rax, %rax
jle 0x5277
movq 0x8(%rsi), %rcx
movq (%rcx), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
movq (%rdi), %rsi
movq 0x8(%rsi), %rsi
movq (%rsi), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rdi
xorl %r8d, %r8d
movsd (%rcx,%r8,8), %xmm0
movsd %xmm0, (%rsi,%r8,8)
movsd (%rdx,%r8,8), %xmm0
movsd %xmm0, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0x5257
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
callq 0x513c
movq %rax, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
testq %rax, %rax
je 0x52bc
movq %rax, %rbx
movq %r14, (%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
testq %rax, %rax
je 0x52bc
movq %rbx, 0x8(%rax)
jmp 0x52be
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x5304
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
movq %rax, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
movq %rbx, 0x8(%rax)
movl $0x1, (%r14)
movq %rax, 0x8(%r14)
jmp 0x5307
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: RcreateRoot(RhdrNd*)
RHdrNd RcreateRoot(RHdrNd hdrNdTree)
{
    RHdrNd hdrNdRoot = RinitHdrNd();
    Dimension iBottomLeft = (Dimension)calloc(DIMENSION, sizeof(double));
    // assert(iBottomLeft != NULL);

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

	RLstNd 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 = RinitLstNd(RinitIntNd(iBottomLeft, iTopRight));
    hdrNdRoot->ptrFirstNd->ptrChildLst = hdrNdTree;
	hdrNdRoot->uiCnt = 1;

	return hdrNdRoot;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x437c
movq %rax, %r14
leaq 0x12038(%rip), %rax     # 0x17364
movslq (%rax), %r12
movl $0x8, %esi
movq %r12, %rdi
callq 0x31b0
movq %rax, %r15
movl $0x8, %esi
movq %r12, %rdi
callq 0x31b0
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x53ca
movl %r12d, %edx
xorl %esi, %esi
testl %edx, %edx
jle 0x53be
movq (%rcx), %rdi
movq 0x8(%rdi), %rdi
movq (%rdi), %rdi
movq (%rdi), %r8
xorl %r9d, %r9d
movsd (%r8,%r9,8), %xmm0
testb $0x1, %sil
je 0x53a0
movsd (%r15,%r9,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x538c
movsd %xmm0, (%r15,%r9,8)
movq 0x8(%rdi), %r10
movsd (%r10,%r9,8), %xmm0
ucomisd (%rax,%r9,8), %xmm0
ja 0x53b0
jmp 0x53b6
movsd %xmm0, (%r15,%r9,8)
movq 0x8(%rdi), %r10
movsd (%r10,%r9,8), %xmm0
movsd %xmm0, (%rax,%r9,8)
incq %r9
cmpq %r9, %rdx
jne 0x536e
movq 0x10(%rcx), %rcx
movb $0x1, %sil
testq %rcx, %rcx
jne 0x535a
movq %r15, %rdi
movq %rax, %rsi
callq 0x5279
movq %rax, %rdi
callq 0x4390
movq %rax, 0x8(%r14)
movq %rbx, 0x8(%rax)
movl $0x1, (%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/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:
testq %rdi, %rdi
je 0x565c
pushq %rbp
movq %rsp, %rbp
leaq 0x11d39(%rip), %rax     # 0x17364
movslq (%rax), %rax
testq %rax, %rax
jle 0x5660
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movsd 0xca9e(%rip), %xmm0     # 0x120e0
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
subsd (%rcx,%rsi,8), %xmm1
mulsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x5644
jmp 0x5668
xorps %xmm0, %xmm0
retq
movsd 0xca78(%rip), %xmm0     # 0x120e0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x629e
movq (%rdi), %rax
cmpl $0x1, (%rax)
jne 0x62ad
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43b2
movl (%rbx), %eax
jmp 0x62ea
movq 0x8(%rdi), %rax
cmpl $0x0, (%rax)
jne 0x62be
movq %r14, %rsi
callq 0x51c9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x566a
movq %rax, %r15
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x627d
testl %eax, %eax
je 0x6304
movq %r15, %rdi
callq 0x5d82
movl (%rbx), %eax
incl %eax
movl %eax, (%rbx)
leaq 0x1108b(%rip), %rcx     # 0x1737c
cmpl (%rcx), %eax
seta %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x62f6
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x437c
movq %rax, %r14
xorl %edi, %edi
xorl %esi, %esi
callq 0x5279
movq %rax, %rdi
callq 0x4390
movq %rax, 0x8(%r14)
incl (%r14)
callq 0x437c
movq 0x8(%r14), %rcx
movq %rax, 0x8(%rcx)
cmpl $0x0, (%rbx)
jle 0x6385
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
addq %r15, %rdi
callq 0x52c3
movq %r14, %rdi
movq %rax, %rsi
callq 0x627d
cmpl $0x2, (%r14)
jb 0x6376
movq %r14, %rdi
callq 0x530f
movq %rax, %r14
incq %r12
movslq (%rbx), %rax
addq $0x40, %r15
cmpq %rax, %r12
jl 0x634e
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/RTree.cpp
// Function: RprintTree(RhdrNd*)
void RprintTree(RHdrNd hdrNdTree)
{   

	RLstNd lstNdTemp = hdrNdTree->ptrFirstNd;
	int iCnt = 0;
	static int iIndent = 0;
	iIndent++;

	while(lstNdTemp != NULL)
    {   
    	for(iCnt = 0; iCnt < iIndent; iCnt++)
			printf("---");

		if(lstNdTemp->tnInfo->ndType == INTNODE)
        {   
        	printf("i hav %d children..\n",lstNdTemp->ptrChildLst->uiCnt);
			printf(" BottomLeft: ");

			for(iCnt = 0; iCnt < DIMENSION; iCnt++)
				printf("%lf ", lstNdTemp->tnInfo->tdInfo->rgnRect->iBottomLeft[iCnt]);

            printf(" TopRight: ");

			for(iCnt = 0; iCnt < DIMENSION; iCnt++)
				printf("%lf ", lstNdTemp->tnInfo->tdInfo->rgnRect->iTopRight[iCnt]);

            printf("\n");
			printf("i hav %d children..\n",lstNdTemp->ptrChildLst->uiCnt);
			RprintTree(lstNdTemp->ptrChildLst);
		}
		else
        {   printf(" DataPoint: ");
    		printData(lstNdTemp->tnInfo->tdInfo->dataClstElem);
			printf("\n");
		}
		lstNdTemp = lstNdTemp->ptrNextNd;
	}
	iIndent--;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r13
movl 0x10f13(%rip), %ecx     # 0x172bc
leal 0x1(%rcx), %eax
movl %eax, 0x10f0a(%rip)     # 0x172bc
testq %r13, %r13
je 0x64f7
leaq 0xbd4e(%rip), %rbx      # 0x12110
leaq 0x10f9b(%rip), %r15     # 0x17364
leaq 0xbc5a(%rip), %r12      # 0x1202a
testl %eax, %eax
jle 0x63ed
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3050
incl %r14d
cmpl 0x10ed1(%rip), %r14d    # 0x172bc
jl 0x63d7
movq (%r13), %rax
cmpl $0x0, (%rax)
je 0x6424
leaq 0xbd46(%rip), %rdi      # 0x12143
xorl %eax, %eax
callq 0x3050
movq (%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x410f
movl $0xa, %edi
callq 0x33d0
jmp 0x64e0
movq 0x8(%r13), %rax
movl (%rax), %esi
leaq 0xbce3(%rip), %rdi      # 0x12114
xorl %eax, %eax
callq 0x3050
leaq 0xbcea(%rip), %rdi      # 0x12129
xorl %eax, %eax
callq 0x3050
cmpl $0x0, (%r15)
jle 0x6478
xorl %r14d, %r14d
movq (%r13), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movsd (%rax,%r14,8), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x3050
incq %r14
movslq (%r15), %rax
cmpq %rax, %r14
jl 0x644f
leaq 0xbcb8(%rip), %rdi      # 0x12137
xorl %eax, %eax
callq 0x3050
cmpl $0x0, (%r15)
jle 0x64b9
xorl %r14d, %r14d
movq (%r13), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movsd (%rax,%r14,8), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x3050
incq %r14
movslq (%r15), %rax
cmpq %rax, %r14
jl 0x648f
movl $0xa, %edi
callq 0x33d0
movq 0x8(%r13), %rax
movl (%rax), %esi
leaq 0xbc44(%rip), %rdi      # 0x12114
xorl %eax, %eax
callq 0x3050
movq 0x8(%r13), %rdi
callq 0x6391
movq 0x10(%r13), %r13
movl 0x10dd2(%rip), %eax     # 0x172bc
testq %r13, %r13
jne 0x63d0
decl %eax
movl %eax, %ecx
movl %ecx, 0x10dbf(%rip)     # 0x172bc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/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
leaq 0x10e4d(%rip), %rax     # 0x17364
movslq (%rax), %rax
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testq %rax, %rax
jle 0x6543
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm2
subsd (%rsi,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x6529
ucomisd %xmm1, %xmm0
jb 0x654f
sqrtsd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x10e04(%rip), %rax     # 0x17364
movslq (%rax), %rcx
movl $0x1, %eax
testq %rcx, %rcx
jle 0x659d
movq (%rdi), %rdx
xorl %r8d, %r8d
movsd (%rdx,%r8,8), %xmm1
movsd (%rsi,%r8,8), %xmm0
ucomisd %xmm0, %xmm1
ja 0x659b
movq 0x8(%rdi), %r9
ucomisd (%r9,%r8,8), %xmm0
ja 0x659b
incq %r8
cmpq %r8, %rcx
jne 0x6573
jmp 0x659d
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x66e0
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x66ce
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x66ce
movq (%r14), %rax
movl (%rax), %ecx
cmpl $0x1, %ecx
je 0x66a3
testl %ecx, %ecx
jne 0x665c
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x3310
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x3310
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x3310
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x3310
movq (%r14), %rdi
callq 0x3310
movq 0x8(%r14), %rdi
callq 0x663d
movq 0x10(%r14), %r15
movq %r14, %rdi
callq 0x3310
movq %r15, %r14
jmp 0x665c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3310
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ADAPTLab[P]MuDBSCAN/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
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
movq %rax, %rbx
testq %r15, %r15
jne 0x68f9
leaq 0x10a7b(%rip), %rax     # 0x17364
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x31b0
movq %rax, %r15
movq %r15, (%rbx)
testq %r14, %r14
jne 0x6918
leaq 0x10a5c(%rip), %rax     # 0x17364
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x31b0
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_O3/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 %r14
pushq %rbx
callq 0x68bb
movq %rax, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
movq %rax, %r14
movq %rbx, (%rax)
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
movq %r14, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
movq %rax, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
movl (%rbx), %ecx
movl %ecx, 0x8(%rax)
movl $0x1, (%r14)
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6a30
cmpl $0x1, %eax
jne 0x6a81
leaq 0x1099a(%rip), %rax     # 0x17364
movslq (%rax), %rax
testq %rax, %rax
jle 0x6a81
leaq 0x109c3(%rip), %rcx     # 0x173a0
movq (%rcx), %rcx
movq (%rcx), %rcx
movq 0x8(%rsi), %rdx
movslq 0x8(%rdx), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x38(%rcx), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
movq (%rdi), %rsi
movq 0x8(%rsi), %rsi
movq (%rsi), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rdi
xorl %r8d, %r8d
movsd (%rcx,%r8,8), %xmm0
movsd %xmm0, (%rsi,%r8,8)
movsd (%rdx,%r8,8), %xmm0
movsd %xmm0, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0x6a0e
jmp 0x6a81
leaq 0x1092d(%rip), %rax     # 0x17364
movslq (%rax), %rax
testq %rax, %rax
jle 0x6a81
movq 0x8(%rsi), %rcx
movq (%rcx), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
movq (%rdi), %rsi
movq 0x8(%rsi), %rsi
movq (%rsi), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rdi
xorl %r8d, %r8d
movsd (%rcx,%r8,8), %xmm0
movsd %xmm0, (%rsi,%r8,8)
movsd (%rdx,%r8,8), %xmm0
movsd %xmm0, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0x6a61
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6f1a
movq (%rdi), %rax
cmpl $0x1, (%rax)
jne 0x6f2a
movq %r14, %rdi
movq %r12, %rsi
callq 0x423e
cmpl %ebx, (%r14)
jmp 0x6f76
movl %edx, %r15d
movq 0x8(%rdi), %rax
cmpl $0x0, (%rax)
jne 0x6f3e
movq %r12, %rsi
callq 0x69b0
movq %r14, %rdi
movq %r12, %rsi
callq 0x6a83
movq %rax, %r13
movq 0x8(%rax), %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %ebx, %ecx
callq 0x6ef3
testl %eax, %eax
je 0x6f8b
movq %r13, %rdi
movl %r15d, %esi
callq 0x6f8f
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 0x6f79