LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/davinash[P]regex/src/regex.cpp
// Function: RegEx::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool RegEx::Match(std::string strText) {
	m_strText = strText;
	RegExState *pState = m_DFATable[0];
	std::vector<RegExState*>  Transition;
	for(int i = 0; i < (int)m_strText.size(); ++i) {
		char CurrChar = m_strText[i];		
		pState->GetTransition(CurrChar, Transition);
		if ( Transition.empty())
			return false;
		pState = Transition[0];
		if ( pState->m_bAcceptingState )
			return true;
		
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x100(%rdi), %r14
movq %r14, %rdi
callq 0x20c0
movq 0x18(%rbx), %rax
movq (%rax), %rdi
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
xorl %r12d, %r12d
movslq 0x108(%rbx), %rax
cmpq %rax, %r12
jge 0x54db
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movq %r15, %rdx
callq 0x7b1e
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x54db
movq (%rax), %rdi
incq %r12
cmpb $0x1, 0x6c(%rdi)
jne 0x54a4
movb $0x1, %bl
jmp 0x54dd
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x6a06
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6a06
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/davinash[P]regex/src/regex.cpp
// Function: RegEx::PreProcessLiterals()
int RegEx::PreProcessLiterals() {
  if (m_CurPreProcChar == '\0') 
	  return -1;
  if (m_CurPreProcChar == '\\') {
    m_CurPreProcChar = *(m_InfixRegEx++);
    if (m_CurPreProcChar == '\0') 
		return -1;
    m_PostStrRegEx += m_CurPreProcChar;
    m_CurPreProcChar = *(m_InfixRegEx++);
  } else if (strchr("()|*+?", m_CurPreProcChar) == NULL) { 
    if (m_CurPreProcChar == '&')
		m_PostStrRegEx += "\\&";
    else 
		m_PostStrRegEx += m_CurPreProcChar;

    m_CurPreProcChar = *(m_InfixRegEx++);
  } else if (m_CurPreProcChar == '(') {
    m_CurPreProcChar = *(m_InfixRegEx++);
    PreProcessOr();
    if (m_CurPreProcChar != ')') 
		return -1;
    m_CurPreProcChar = *(m_InfixRegEx++);
  } else
		return -1;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movzbl 0x148(%rdi), %r15d
pushq $-0x1
popq %rbp
testl %r15d, %r15d
je 0x55e5
movq %rdi, %rbx
cmpl $0x5c, %r15d
jne 0x5558
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
testb %al, %al
je 0x55e5
leaq 0x120(%rbx), %rdi
movsbl %al, %esi
jmp 0x55c4
movsbl %r15b, %r14d
leaq 0x4083(%rip), %rdi      # 0x95e6
pushq $0x7
popq %rdx
movl %r14d, %esi
callq 0x21c0
testq %rax, %rax
je 0x55a6
cmpb $0x28, %r15b
jne 0x55e5
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
movq %rbx, %rdi
callq 0x55f2
cmpb $0x29, 0x148(%rbx)
je 0x55c9
jmp 0x55e5
leaq 0x120(%rbx), %rdi
cmpb $0x26, %r15b
jne 0x55c1
leaq 0x4033(%rip), %rsi      # 0x95ed
callq 0x22b0
jmp 0x55c9
movl %r14d, %esi
callq 0x2150
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/davinash[P]regex/src/regex.cpp
// Function: RegEx::PreProcessOr()
int RegEx::PreProcessOr() {
	PrePreprocessConcatenation();
	while (m_CurPreProcChar == '|') {
		m_CurPreProcChar = *(m_InfixRegEx++);
		PrePreprocessConcatenation();
		m_PostStrRegEx += "|";
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x56c0
leaq 0x120(%rbx), %r14
leaq 0x3fd7(%rip), %r15      # 0x95e4
cmpb $0x7c, 0x148(%rbx)
jne 0x5645
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
movq %rbx, %rdi
callq 0x56c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x22b0
jmp 0x560d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davinash[P]regex/src/regex.cpp
// Function: RegEx::PreProcessClosure()
int RegEx::PreProcessClosure() {
	PreProcessLiterals();
	while (m_CurPreProcChar != '\0' && strchr("*+?",m_CurPreProcChar) != NULL) {
		m_PostStrRegEx += m_CurPreProcChar;
		m_CurPreProcChar = *(m_InfixRegEx++);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x5506
leaq 0x120(%rbx), %r14
movb 0x148(%rbx), %al
leaq 0x3f77(%rip), %r15      # 0x95e9
pushq $0x4
popq %r12
testb %al, %al
je 0x56b5
movsbl %al, %ebp
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x21c0
testq %rax, %rax
je 0x56b5
movq %r14, %rdi
movl %ebp, %esi
callq 0x2150
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
jmp 0x5676
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/davinash[P]regex/src/regex.cpp
// Function: RegEx::PrePreprocessConcatenation()
int RegEx::PrePreprocessConcatenation(void) {
	PreProcessClosure();
	while (strchr(")|*+?", m_CurPreProcChar) == NULL) { 
		PreProcessClosure();
		m_PostStrRegEx += "&";
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x564e
leaq 0x120(%rbx), %r14
leaq 0x3f08(%rip), %r15      # 0x95e7
pushq $0x6
popq %r12
leaq 0x3f04(%rip), %r13      # 0x95ee
movsbl 0x148(%rbx), %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x21c0
testq %rax, %rax
jne 0x5716
movq %rbx, %rdi
callq 0x564e
movq %r14, %rdi
movq %r13, %rsi
callq 0x22b0
jmp 0x56ea
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/davinash[P]regex/src/regexstate.cpp
// Function: RegExState::RegExState(std::set<RegExState*, std::less<RegExState*>, std::allocator<RegExState*>>, int)
RegExState::RegExState(std::set<RegExState*> NFAState, int nID) {
	m_NFAStates = NFAState;
	m_nStateID = nID;
	m_bAcceptingState = false;
	m_GroupID = 0;
	StateIterator iter;
	for(iter = NFAState.begin(); iter != NFAState.end(); ++iter) {
		if((*iter)->m_bAcceptingState) {
			m_bAcceptingState = true;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x643c(%rip), %rax      # 0xdd98
movq %rax, (%rdi)
leaq 0x8(%rdi), %r15
leaq 0x10(%rdi), %rax
andl $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x40(%rdi), %rax
andl $0x0, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rax, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
movq %r15, %rdi
callq 0x612e
movl %ebp, 0x68(%rbx)
movb $0x0, 0x6c(%rbx)
andl $0x0, 0x70(%rbx)
movq 0x18(%r14), %rax
addq $0x8, %r14
cmpq %r14, %rax
je 0x79cf
movq 0x20(%rax), %rcx
cmpb $0x1, 0x6c(%rcx)
jne 0x79c5
movb $0x1, 0x6c(%rbx)
movq %rax, %rdi
callq 0x21d0
jmp 0x79b2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x7c8e
movq %r15, %rdi
callq 0x6634
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7ce6
movl 0x68(%rbx), %eax
movl %eax, 0x68(%r14)
addq $0x8, %rbx
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x612e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davinash[P]regex/src/regexstate.cpp
// Function: RegExState::RemoveTransition(RegExState*)
void RegExState::RemoveTransition(RegExState* pState) {
	std::multimap<char, RegExState*>::iterator iter;
	for(iter = m_Transition.begin(); iter != m_Transition.end();) {
		RegExState *toState = iter->second;
		if(toState == pState)
			m_Transition.erase(iter++);
		else 
			++iter;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rdi), %r15
movq 0x50(%rdi), %r13
addq $0x40, %r14
cmpq %r14, %r13
je 0x7b0e
movq %r13, %r12
movq 0x28(%r13), %rbp
movq %r13, %rdi
callq 0x20f0
movq %rax, %r13
cmpq %rbx, %rbp
jne 0x7ae5
movq %r15, %rdi
movq %r12, %rsi
callq 0x80b0
jmp 0x7ae5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movb %sil, 0x7(%rsp)
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x7b43
movq %rax, 0x8(%rbx)
addq $0x38, %r14
leaq 0x7(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x80fe
movq %rax, %r13
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x812c
cmpq %rax, %r13
je 0x7b90
movq 0x28(%r13), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5da4
movq %r13, %rdi
callq 0x20f0
movq %rax, %r13
jmp 0x7b5f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpb $0x0, 0x6c(%rdi)
je 0x7bae
xorl %ecx, %ecx
jmp 0x7be5
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
je 0x7bdc
movq 0x50(%rbx), %rax
leaq 0x40(%rbx), %r14
cmpq %r14, %rax
sete %cl
je 0x7bde
cmpq %rbx, 0x28(%rax)
jne 0x7bde
movq %rax, %rdi
callq 0x20f0
jmp 0x7bc4
movb $0x1, %cl
addq $0x8, %rsp
popq %rbx
popq %r14
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %rdi
callq 0x2100
leaq 0x30(%rsp), %rdi
movl 0x68(%r14), %esi
callq 0x2280
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x2240
leaq 0x20(%rsp), %rdi
callq 0x2120
movq %rsp, %rdi
callq 0x2090
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x7c7e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2120
movq %rsp, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/vectorc.cpp
// Function: vector_init(vectorc*, VECTORTYPE)
void vector_init(vectorc* v, VECTORTYPE type)
{
    v->capacity = VECTOR_INIT_CAPACITY;
    v->total = 0;
    v->type = type;

    switch (v->type)
    {
        case GROUP:
            v->doubleItems = NULL;
            v->intItems = NULL;
            v->groupItems = (Group*)calloc(v->capacity, sizeof(Group));
            // assert(v->groupItems != NULL);
        break;


        case DOUBLE:
            v->intItems = NULL;
            v->groupItems = NULL;
            v->doubleItems = (double*)calloc(v->capacity, sizeof(double));
            // assert(v->doubleItems != NULL);
        break;

        case INTEGER:
            v->doubleItems = NULL;
            v->groupItems = NULL;
            v->intItems = (int*)calloc(v->capacity, sizeof(int));
            // assert(v->intItems != NULL);
        break;

        // default:
        //     fprintf(stderr, "In VECTOR_INIT(): Pass in a valid type\n");
        //     exit(-1);
        // break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x4, 0x20(%rdi)
movl %esi, 0x28(%rdi)
testl %esi, %esi
je 0x27fc
cmpl $0x2, %esi
je 0x27e5
cmpl $0x1, %esi
jne 0x2814
pushq $0x4
popq %rdi
pushq $0x8
popq %rsi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rax, (%rbx)
jmp 0x2814
pushq $0x4
popq %rdi
pushq $0x8
popq %rsi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rax, 0x10(%rbx)
jmp 0x2814
andq $0x0, 0x10(%rbx)
andq $0x0, (%rbx)
pushq $0x4
popq %rdi
movq %rdi, %rsi
callq 0x2180
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a12
movl 0x28(%rbx), %esi
movq %rbx, %rdi
callq 0x27ac
movl 0x20(%rbx), %esi
cmpl 0x24(%rbx), %esi
jne 0x2a21
addl %esi, %esi
movq %rbx, %rdi
callq 0x2958
movl 0x28(%rbx), %eax
cmpl $0x2, %eax
je 0x2a5b
cmpl $0x1, %eax
je 0x2a48
testl %eax, %eax
jne 0x2a73
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 0x2a73
movq (%rbx), %rax
movslq 0x24(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movq %r14, (%rax,%rcx,8)
jmp 0x2a73
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_O2/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, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, %rbx
movq %rdi, -0x48(%rbp)
xorl %r14d, %r14d
movq (%rbx), %r15
movq 0x8(%rbx), %rcx
movq %rcx, %rax
subq %r15, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %r14, %rax
jbe 0x2c6a
leaq 0x1176d(%rip), %rax     # 0x14334
movslq (%rax), %r13
movq %r13, %rdi
pushq $0x8
popq %rsi
callq 0x2180
imulq $0x18, %r14, %r12
addq %r12, %r15
testl %r13d, %r13d
movl $0x0, %ecx
cmovgl %r13d, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2c01
movq (%r15), %rsi
movsd (%rsi,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0x2bea
movq -0x50(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl (%rcx,%r14,4), %edx
movq -0x58(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl (%rcx,%r14,4), %ecx
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2b1a
andq $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq (%rbx), %rax
movq (%rax,%r12), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax,%r12), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax,%r12), %rcx
movq %rcx, -0x30(%rbp)
movups %xmm0, (%rax,%r12)
andq $0x0, 0x10(%rax,%r12)
leaq -0x40(%rbp), %rdi
callq 0x2ede
incq %r14
jmp 0x2ba2
leaq -0x40(%rbp), %rdi
movq %r15, (%rdi)
movq %rcx, 0x8(%rdi)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
callq 0x2ea4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/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, -0x58(%rbp)
movq 0x11299(%rip), %rdi     # 0x13fb0
leaq -0x2c(%rbp), %rsi
callq 0x2370
xorl %r15d, %r15d
movq (%rbx), %r12
movq 0x8(%rbx), %rcx
movq %rcx, %rax
subq %r12, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %r15, %rax
jbe 0x2dd7
leaq 0x115ec(%rip), %rax     # 0x14334
movslq (%rax), %r13
movq %r13, %rdi
pushq $0x8
popq %rsi
callq 0x2180
imulq $0x18, %r15, %r14
addq %r14, %r12
testl %r13d, %r13d
movl $0x0, %ecx
cmovgl %r13d, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2d83
movq (%r12), %rsi
movsd (%rsi,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0x2d6b
movl -0x2c(%rbp), %edx
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x2c9c
andq $0x0, -0x40(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq (%rbx), %rax
movq (%rax,%r14), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax,%r14), %rcx
movq %rcx, -0x48(%rbp)
movq 0x10(%rax,%r14), %rcx
movq %rcx, -0x40(%rbp)
movups %xmm0, (%rax,%r14)
andq $0x0, 0x10(%rax,%r14)
leaq -0x50(%rbp), %rdi
callq 0x2ede
incq %r15
jmp 0x2d23
leaq -0x50(%rbp), %rdi
movq %r12, (%rdi)
movq %rcx, 0x8(%rdi)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
callq 0x2ea4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/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 0xc1e3(%rip), %rdi      # 0xf004
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x2040
leaq 0x11502(%rip), %r12     # 0x14334
leaq 0xc1d5(%rip), %r14      # 0xf00e
movslq (%r12), %rax
cmpq %rax, %r15
jge 0x2e5a
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x2040
incq %r15
jmp 0x2e39
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq (%rbx), %rax
movq 0x8(%rbx), %rdi
cmpq %rax, %r15
jge 0x2e94
movq (%rdi,%r14), %rdi
callq 0x2280
incq %r15
addq $0x40, %r14
jmp 0x2e76
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2fac
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsi)
movq %rsi, 0x8(%rdi)
incl (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x2ffb
cmpl $0x0, (%rdi)
je 0x2ffb
cmpq %rsi, (%rcx)
je 0x2fff
movq %rcx, %rax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x2ffb
cmpq %rsi, (%rcx)
jne 0x2fe1
movq %rax, %rsi
popq %rbp
jmp 0x302e
xorl %eax, %eax
popq %rbp
retq
popq %rbp
jmp 0x3005
// File: /workspace/github_cpp_makefile_star2_O2/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 0x30ec
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsi)
movq %rsi, 0x8(%rdi)
incl (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x30ee
testl %eax, %eax
je 0x312a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rbx), %rax
cmpq %r14, (%rax)
je 0x3150
movq %rax, %rsi
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x3123
cmpq %r14, (%rax)
jne 0x3133
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x318c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x315c
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x30ee
testl %eax, %eax
je 0x3172
xorl %eax, %eax
jmp 0x3185
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rbx)
decl (%rbx)
andq $0x0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x30ee
movl %eax, %ecx
xorl %eax, %eax
testq %r14, %r14
je 0x31c7
testl %ecx, %ecx
jne 0x31c7
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x31c5
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r14)
andq $0x0, 0x10(%rax)
decl (%rbx)
jmp 0x31c7
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2831
leaq 0xb73b(%rip), %rsi      # 0xf013
movq %rbx, %rdi
movl %r12d, %edx
movl %r15d, %ecx
movl %r13d, %r8d
movl %eax, %r9d
xorl %eax, %eax
callq 0x2390
movl (%r14), %edx
movq 0x10(%r14), %rcx
movq 0x8(%r14), %r8
movq 0x58(%r14), %r9
leaq 0xb746(%rip), %rsi      # 0xf04a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2390
movl (%r14), %edx
movq 0x50(%r14), %rcx
movq 0x38(%r14), %r8
leaq 0xb761(%rip), %rsi      # 0xf081
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2390
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10a37(%rip), %rax     # 0x14388
incl (%rax)
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
callq 0x2180
movq %rax, %rbx
leaq 0x109ec(%rip), %rax     # 0x14354
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)
pushq $0x30
popq %r14
movq %r14, %rdi
callq 0x2320
movq %rax, 0x10(%rbx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x27ac
movq %r14, %rdi
callq 0x2320
movq %rax, 0x8(%rbx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x27ac
movq %r14, %rdi
callq 0x2320
movq %rax, 0x58(%rbx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x27ac
movq %r14, %rdi
callq 0x2320
movq %rax, 0x50(%rbx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x27ac
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x2180
movq %rax, %r14
leaq 0x1092b(%rip), %rax     # 0x14334
movslq (%rax), %r13
pushq $0x8
popq %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x2180
movq %rax, %r15
movq %rax, (%r14)
movq %r13, %rdi
movq %r12, %rsi
callq 0x2180
movq %rax, %r12
movq %rax, 0x8(%r14)
movq %r13, %rdi
pushq $0x8
popq %rsi
callq 0x2180
movq %rax, 0x10(%r14)
movq %r13, %rdi
pushq $0x8
popq %rsi
callq 0x2180
movq %rax, 0x18(%r14)
leaq 0x10900(%rip), %rax     # 0x14358
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movl %ecx, 0x28(%r14)
xorl %eax, %eax
testl %r13d, %r13d
movl $0x0, %ecx
cmovgl %r13d, %ecx
cmpq %rax, %rcx
je 0x3a98
movq (%rbx), %rdx
movsd (%rdx,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
movq 0x8(%rbx), %rdx
movsd (%rdx,%rax,8), %xmm0
movsd %xmm0, (%r12,%rax,8)
incq %rax
jmp 0x3a71
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/MuC.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 0x2280
movq 0x38(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x2280
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x2280
movq 0x38(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x2280
movq 0x38(%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x4f36
movq 0x38(%rbx), %rdi
callq 0x2280
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2180
testq %rax, %rax
je 0x3cf9
movq %rax, %rbx
testq %r15, %r15
je 0x3cb1
movq %r15, (%rbx)
jmp 0x3ccb
leaq 0x1067c(%rip), %rax     # 0x14334
movslq (%rax), %rdi
pushq $0x8
popq %rsi
callq 0x2180
movq %rax, (%rbx)
testq %rax, %rax
je 0x3cf1
testq %r14, %r14
je 0x3cd6
movq %r14, 0x8(%rbx)
jmp 0x3cfb
leaq 0x10657(%rip), %rax     # 0x14334
movslq (%rax), %rdi
pushq $0x8
popq %rsi
callq 0x2180
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x3cfb
movq %rbx, %rdi
callq 0x2280
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/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 0x3d66
cmpl $0x1, %eax
jne 0x3db5
leaq 0x10611(%rip), %rax     # 0x14334
movl (%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x3db5
movq 0x8(%rsi), %rdx
movq 0x8(%rdx), %rdx
movq (%rdx), %rdx
movsd (%rdx,%rcx,8), %xmm0
movq (%rdi), %rdx
movq 0x8(%rdx), %rdx
movq (%rdx), %rdx
movq (%rdx), %r8
movsd %xmm0, (%r8,%rcx,8)
movq 0x8(%rdx), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0x3d2c
leaq 0x105c7(%rip), %rax     # 0x14334
movl (%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x3db5
movq 0x8(%rsi), %rdx
movq (%rdx), %rdx
movq (%rdx), %r8
movsd (%r8,%rcx,8), %xmm0
movq (%rdi), %r8
movq 0x8(%r8), %r8
movq (%r8), %r8
movq (%r8), %r9
movsd %xmm0, (%r9,%rcx,8)
movq 0x8(%rdx), %rdx
movsd (%rdx,%rcx,8), %xmm0
movq 0x8(%r8), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0x3d76
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3c84
movq %rax, %r14
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2180
testq %rax, %rax
je 0x3df2
movq %rax, %rbx
movq %r14, (%rax)
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2180
testq %rax, %rax
je 0x3df2
movq %rbx, 0x8(%rax)
jmp 0x3df4
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x3e3e
movq %rdi, %rbx
pushq $0x1
popq %r15
pushq $0x10
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2180
movq %rax, %r14
movq %r15, %rdi
movq %r12, %rsi
callq 0x2180
movq %rbx, 0x8(%rax)
movl $0x1, (%r14)
movq %rax, 0x8(%r14)
jmp 0x3e41
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x306c
movq %rax, %r14
leaq 0x104c7(%rip), %rax     # 0x14334
movslq (%rax), %r12
pushq $0x8
popq %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
movq %rax, %r15
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
leaq 0x8(%rbx), %rcx
xorl %esi, %esi
testl %r12d, %r12d
movl $0x0, %edx
cmovgl %r12d, %edx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x3f0f
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x3f06
movq (%rcx), %r8
movq 0x8(%r8), %r8
movq (%r8), %r8
movq (%r8), %r9
movsd (%r9,%rdi,8), %xmm0
testb $0x1, %sil
je 0x3eec
movsd (%r15,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3ed9
movsd %xmm0, (%r15,%rdi,8)
movq 0x8(%r8), %r8
movsd (%r8,%rdi,8), %xmm0
ucomisd (%rax,%rdi,8), %xmm0
ja 0x3efc
jmp 0x3f01
movsd %xmm0, (%r15,%rdi,8)
movq 0x8(%r8), %r8
movsd (%r8,%rdi,8), %xmm0
movsd %xmm0, (%rax,%rdi,8)
incq %rdi
jmp 0x3ea9
addq $0x10, %rcx
movb $0x1, %sil
jmp 0x3e9f
movq %r15, %rdi
movq %rax, %rsi
callq 0x3db7
movq %rax, %rdi
callq 0x308a
movq %rax, 0x8(%r14)
movq %rbx, 0x8(%rax)
movl $0x1, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/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 0x411d
pushq %rbp
movq %rsp, %rbp
leaq 0x10249(%rip), %rax     # 0x14334
movl (%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movsd 0xafd4(%rip), %xmm0     # 0xf0d0
cmpq %rcx, %rax
je 0x411b
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
movsd (%rsi,%rcx,8), %xmm1
subsd (%rdx,%rcx,8), %xmm1
mulsd %xmm1, %xmm0
incq %rcx
jmp 0x40fc
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4bbe
movq (%rdi), %rax
cmpl $0x1, (%rax)
jne 0x4bcd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30a8
movl (%rbx), %eax
jmp 0x4c0a
movq 0x8(%rdi), %rax
cmpl $0x0, (%rax)
jne 0x4bde
movq %r14, %rsi
callq 0x3d09
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4121
movq %rax, %r15
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x4b9d
testl %eax, %eax
je 0x4c24
movq %r15, %rdi
callq 0x4750
movl (%rbx), %eax
incl %eax
movl %eax, (%rbx)
leaq 0xf73b(%rip), %rcx      # 0x1434c
cmpl (%rcx), %eax
seta %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x4c16
// File: /workspace/github_cpp_makefile_star2_O2/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 0x306c
movq %rax, %r14
xorl %r15d, %r15d
xorl %edi, %edi
xorl %esi, %esi
callq 0x3db7
movq %rax, %rdi
callq 0x308a
movq %rax, 0x8(%r14)
incl (%r14)
callq 0x306c
movq 0x8(%r14), %rcx
movq %rax, 0x8(%rcx)
xorl %r12d, %r12d
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x4ca2
movq 0x8(%rbx), %rdi
addq %r15, %rdi
callq 0x3df9
movq %r14, %rdi
movq %rax, %rsi
callq 0x4b9d
cmpl $0x2, (%r14)
jb 0x4c99
movq %r14, %rdi
callq 0x3e4d
movq %rax, %r14
incq %r12
addq $0x40, %r15
jmp 0x4c69
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
incl 0xf5c6(%rip)            # 0x1428c
leaq 0xa423(%rip), %rbx      # 0xf0f0
leaq 0xf660(%rip), %r14      # 0x14334
leaq 0xa333(%rip), %r12      # 0xf00e
testq %r13, %r13
je 0x4def
xorl %r15d, %r15d
cmpl 0xf59e(%rip), %r15d     # 0x1428c
jge 0x4cff
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2040
incl %r15d
jmp 0x4ce7
movq (%r13), %rax
cmpl $0x0, (%rax)
je 0x4d34
leaq 0xa414(%rip), %rdi      # 0xf123
xorl %eax, %eax
callq 0x2040
movq (%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2e09
pushq $0xa
popq %rdi
callq 0x2360
jmp 0x4de6
movq 0x8(%r13), %rax
movl (%rax), %esi
leaq 0xa3b3(%rip), %rdi      # 0xf0f4
xorl %eax, %eax
callq 0x2040
leaq 0xa3ba(%rip), %rdi      # 0xf109
xorl %eax, %eax
callq 0x2040
xorl %r15d, %r15d
movslq (%r14), %rax
cmpq %rax, %r15
jge 0x4d84
movq (%r13), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movsd (%rax,%r15,8), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x2040
incq %r15
jmp 0x4d59
leaq 0xa38c(%rip), %rdi      # 0xf117
xorl %eax, %eax
callq 0x2040
xorl %r15d, %r15d
movslq (%r14), %rax
cmpq %rax, %r15
jge 0x4dc1
movq (%r13), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movsd (%rax,%r15,8), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x2040
incq %r15
jmp 0x4d95
pushq $0xa
popq %rdi
callq 0x2360
movq 0x8(%r13), %rax
movl (%rax), %esi
leaq 0xa31e(%rip), %rdi      # 0xf0f4
xorl %eax, %eax
callq 0x2040
movq 0x8(%r13), %rdi
callq 0x4cae
movq 0x10(%r13), %r13
jmp 0x4cdb
decl 0xf497(%rip)            # 0x1428c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ADAPTLab[P]MuDBSCAN/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 0xf525(%rip), %rax      # 0x14334
movl (%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x4e38
movsd (%rdi,%rcx,8), %xmm1
subsd (%rsi,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
jmp 0x4e1c
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4e48
sqrtsd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf4db(%rip), %rax      # 0x14334
movl (%rax), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movl $0x1, %r8d
cmpq %rdx, %rcx
je 0x4e94
movq (%rdi), %rax
movsd (%rax,%rdx,8), %xmm1
movsd (%rsi,%rdx,8), %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm1
ja 0x4e97
movq 0x8(%rdi), %r9
ucomisd (%r9,%rdx,8), %xmm0
leaq 0x1(%rdx), %rdx
jbe 0x4e68
jmp 0x4e97
movl %r8d, %eax
popq %rbp
retq