LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/davinash[P]regex/src/regex.cpp
// Function: RegEx::ReduceDFA()
void RegEx::ReduceDFA() {
	std::set<RegExState*> DeadEndSet;
	for(int i = 0; i < (int)m_DFATable.size(); ++i) {
		if(m_DFATable[i]->IsDeadEnd()) {
			DeadEndSet.insert(m_DFATable[i]);
		}
	}
	if(DeadEndSet.empty())
		return;
	StateIterator iter;
	for(iter = DeadEndSet.begin(); iter != DeadEndSet.end(); ++iter) {
		for(int i = 0; i < (int)m_DFATable.size(); ++i)
			m_DFATable[i]->RemoveTransition(*iter);

		TableIterator pos;
		for(pos = m_DFATable.begin(); pos != m_DFATable.end(); ++pos) {
			if(*pos == *iter) {
				break;
			}
		}
		m_DFATable.erase(pos);
		delete *iter;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rax, 0x20(%r15)
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x64ca
xorl %r12d, %r12d
movq %rsp, %r14
xorl %r13d, %r13d
movq (%rax,%r12), %rdi
callq 0x965c
testb %al, %al
je 0x64ac
movq 0x18(%rbx), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x91d2
incq %r13
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
addq $0x8, %r12
cmpq %rcx, %r13
jl 0x6490
cmpq $0x0, 0x28(%rsp)
sete %al
movq 0x18(%rsp), %r14
cmpq %r15, %r14
sete %cl
orb %al, %cl
jne 0x6588
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rdx
movq %rdx, %rax
subq %rdi, %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x6528
xorl %r12d, %r12d
movq (%rdi,%r12,8), %rdi
movq 0x20(%r14), %rsi
callq 0x9542
incq %r12
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rdx
movq %rdx, %rax
subq %rdi, %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r12
jl 0x64ff
movq %rdi, %rax
cmpq %rdx, %rdi
je 0x6545
movq 0x20(%r14), %rcx
movq %rdi, %rax
cmpq %rcx, (%rax)
je 0x6545
addq $0x8, %rax
cmpq %rdx, %rax
jne 0x6537
subq %rdi, %rax
leaq (%rdi,%rax), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x6560
addq %rax, %rdi
subq %rsi, %rdx
callq 0x2220
addq $-0x8, 0x20(%rbx)
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x6574
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x21c0
movq %rax, %r14
cmpq %r15, %rax
jne 0x64e6
movq %rsp, %rdi
callq 0x8202
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x65a0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8202
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/davinash[P]regex/src/regex.cpp
// Function: RegEx::Compile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool RegEx::Compile(std::string strRegEx) {

	while ( strRegEx.find( "[" ) != std::string::npos ) {
		strRegEx = PreProcessBracket(strRegEx);
	}

	m_InfixRegEx = const_cast<char*>(strRegEx.c_str());
	CleanUp();
	
	if(!ConstructThompsonNFA())
		return false;	

	PopTable( m_NFATable);
	m_NFATable[m_NFATable.size() - 1 ]->m_bAcceptingState = true;
	
	ConvertNFAtoDFA();
	MinimizeDFA();
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, (%rsp)
leaq 0x3cb0(%rip), %rsi      # 0xa5e0
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x2250
cmpq $-0x1, %rax
je 0x69d7
leaq 0x18(%rsp), %rbp
leaq 0x38(%rsp), %rbx
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
leaq 0x3c7c(%rip), %r13      # 0xa5e0
movq %rbp, 0x8(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x8216
movq %r12, %rdi
movq %r15, %rdx
callq 0x65b6
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x69a8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x69bf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movl $0x1, %ecx
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2250
cmpq $-0x1, %rax
jne 0x6964
movq (%r14), %rax
movq (%rsp), %rbx
movq %rax, 0x140(%rbx)
movq %rbx, %rdi
callq 0x4ebe
movq %rbx, %rdi
callq 0x6a48
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x500a
movq 0x8(%rbx), %rax
movq -0x8(%rax), %rax
movb $0x1, 0x6c(%rax)
movq %rbx, %rdi
callq 0x5eec
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6a3f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/davinash[P]regex/src/regex.cpp
// Function: RegEx::ConstructThompsonNFA()
bool RegEx::ConstructThompsonNFA() {
	CovertToPostfix();
	for(int i = 0; i < (int)m_PostStrRegEx.size(); ++i) {
		char curChar = m_PostStrRegEx[i];
		if ( IsInput( curChar )) {
			PushOnCharacterStack( curChar );
		} else if ( IsMetaChar( curChar ) ) {
			switch ( curChar ) {
				case CLOSURE:
					Closure();
					break;
				case PLUS_CLOSURE:
					ClosurePlus();
					break;
				case OPTIONAL:
					ClosureOptional();
					break;
				case OR:
					Or();
					break;
				case FALSE_CONCAT:
					Concatenate();
					break;
			}
		}		
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x140(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rdi)
movb (%rax), %al
movb %al, 0x148(%rdi)
callq 0x6ce0
cmpl $0x0, 0x128(%rbx)
jle 0x6b13
xorl %r14d, %r14d
movq 0x120(%rbx), %rax
movsbl (%rax,%r14), %ebp
movl %ebp, %esi
callq 0x4fce
testb %al, %al
je 0x6ac4
movsbl %bpl, %esi
callq 0x4fce
testb %al, %al
je 0x6ad0
movzbl %bpl, %eax
cmpl $0x2a, %eax
jle 0x6ae1
cmpl $0x2b, %eax
je 0x6af5
cmpl $0x3f, %eax
je 0x6aff
cmpl $0x7c, %eax
jne 0x6ad0
movq %rbx, %rdi
callq 0x5948
jmp 0x6ad0
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x519c
incq %r14
movslq 0x128(%rbx), %rax
cmpq %rax, %r14
jl 0x6a7e
jmp 0x6b13
cmpl $0x26, %eax
je 0x6b09
cmpl $0x2a, %eax
jne 0x6ad0
movq %rbx, %rdi
callq 0x573e
jmp 0x6ad0
movq %rbx, %rdi
callq 0x5546
jmp 0x6ad0
movq %rbx, %rdi
callq 0x535a
jmp 0x6ad0
movq %rbx, %rdi
callq 0x50a8
jmp 0x6ad0
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x100(%rdi), %r15
movq %r15, %rdi
callq 0x20a0
movq 0x18(%r14), %rax
movq (%rax), %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x108(%r14)
jle 0x6ba2
xorl %ebp, %ebp
movq %rsp, %r13
movq (%r15), %rax
movsbl (%rax,%rbp), %esi
movq %r12, %rdi
movq %r13, %rdx
callq 0x959a
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x6b8b
movq (%rax), %r12
movb 0x6c(%r12), %al
orb %al, %bl
xorb $0x1, %al
jmp 0x6b8f
xorl %eax, %eax
xorl %ebx, %ebx
testb %al, %al
je 0x6ba4
incq %rbp
movslq 0x108(%r14), %rax
cmpq %rax, %rbp
jl 0x6b60
xorl %ebx, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6bba
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
andb $0x1, %bl
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6be7
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %r15d, %r15d
je 0x6cd3
movq %rdi, %rbx
cmpl $0x5c, %r15d
jne 0x6c44
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
testb %al, %al
je 0x6cd3
leaq 0x120(%rbx), %rdi
movsbl %al, %esi
jmp 0x6cb2
movsbl %r15b, %r14d
leaq 0x3997(%rip), %rdi      # 0xa5e6
movl $0x7, %edx
movl %r14d, %esi
callq 0x2190
testq %rax, %rax
je 0x6c94
cmpb $0x28, %r15b
jne 0x6cd3
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
movq %rbx, %rdi
callq 0x6ce0
cmpb $0x29, 0x148(%rbx)
je 0x6cb7
jmp 0x6cd3
leaq 0x120(%rbx), %rdi
cmpb $0x26, %r15b
jne 0x6caf
leaq 0x3945(%rip), %rsi      # 0xa5ed
callq 0x2280
jmp 0x6cb7
movl %r14d, %esi
callq 0x2130
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_O1/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 0x6db6
cmpb $0x7c, 0x148(%rbx)
jne 0x6d3a
leaq 0x120(%rbx), %r14
leaq 0x38e0(%rip), %r15      # 0xa5e4
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
movq %rbx, %rdi
callq 0x6db6
movq %r14, %rdi
movq %r15, %rsi
callq 0x2280
cmpb $0x7c, 0x148(%rbx)
je 0x6d04
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6bf0
movb 0x148(%rbx), %al
testb %al, %al
je 0x6da8
leaq 0x120(%rbx), %r14
leaq 0x3880(%rip), %r15      # 0xa5e9
movsbl %al, %ebp
movl $0x4, %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x2190
testq %rax, %rax
je 0x6da8
movq %r14, %rdi
movl %ebp, %esi
callq 0x2130
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
testb %al, %al
jne 0x6d69
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6d42
movsbl 0x148(%rbx), %esi
leaq 0x3813(%rip), %rdi      # 0xa5e7
movl $0x6, %edx
callq 0x2190
testq %rax, %rax
jne 0x6e24
leaq 0x120(%rbx), %r14
leaq 0x37fd(%rip), %r15      # 0xa5ee
leaq 0x37ef(%rip), %r12      # 0xa5e7
movq %rbx, %rdi
callq 0x6d42
movq %r14, %rdi
movq %r15, %rsi
callq 0x2280
movsbl 0x148(%rbx), %esi
movl $0x6, %edx
movq %r12, %rdi
callq 0x2190
testq %rax, %rax
je 0x6df8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49e2(%rip), %rax      # 0xdd90
movq %rax, (%rdi)
leaq 0x8(%rdi), %r15
leaq 0x10(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
leaq 0x40(%rdi), %rax
movl %ecx, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movq %rcx, 0x60(%rdi)
movq %r15, %rdi
callq 0x7d54
movl %ebp, 0x68(%rbx)
movb $0x0, 0x6c(%rbx)
movl $0x0, 0x70(%rbx)
movq 0x18(%r14), %rax
addq $0x8, %r14
cmpq %r14, %rax
je 0x9420
movq 0x20(%rax), %rcx
cmpb $0x1, 0x6c(%rcx)
jne 0x9416
movb $0x1, 0x6c(%rbx)
movq %rax, %rdi
callq 0x21c0
jmp 0x9403
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x97aa
movq %r15, %rdi
callq 0x8202
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/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 0x97fa
movl 0x68(%rbx), %eax
movl %eax, 0x68(%r14)
addq $0x8, %rbx
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x7d54
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x95ba
movq %rax, 0x8(%rbx)
movq 0x48(%r14), %rax
leaq 0x40(%r14), %r13
movq %r13, %r15
testq %rax, %rax
je 0x95e4
movq %r13, %r15
xorl %ecx, %ecx
cmpb %bpl, 0x20(%rax)
setl %cl
cmovgeq %rax, %r15
movq 0x10(%rax,%rcx,8), %rax
testq %rax, %rax
jne 0x95cd
movq %rsp, %r12
movq 0x48(%r14), %rax
movq %r13, %rcx
testq %rax, %rax
je 0x960d
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 0x95f6
cmpq %rcx, %r15
je 0x9646
movq 0x28(%r15), %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x962e
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x9639
movq %rbx, %rdi
movq %r12, %rdx
callq 0x8c2e
movq %r15, %rdi
callq 0x20d0
movq %rax, %r15
jmp 0x95e7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9665
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
je 0x9696
movq 0x50(%rbx), %rdi
leaq 0x40(%rbx), %r14
cmpq %r14, %rdi
sete %al
je 0x9698
cmpq %rbx, 0x28(%rdi)
jne 0x9698
callq 0x20d0
movq %rax, %rdi
cmpq %r14, %rax
jmp 0x967e
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x96c6
cmpq 0x30(%rsi), %rcx
jne 0x96d0
movq 0x20(%rax), %rdi
addq $0x10, %rax
movq 0x20(%rsi), %rdx
movq %rax, %rsi
jmp 0x92e4
movl 0x68(%rax), %eax
cmpl 0x68(%rsi), %eax
sete %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4899(%rip), %rsi      # 0xdfc0
leaq 0x28(%rsp), %rdi
callq 0x2100
leaq 0xa8(%rsp), %rdi
callq 0x2060
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9755
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 0x978b
movq %rax, %rbx
movq 0x484c(%rip), %rsi      # 0xdfc0
leaq 0x28(%rsp), %rdi
callq 0x2100
leaq 0xa8(%rsp), %rdi
callq 0x2060
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x97a2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a14
cmpl $0x2, %esi
je 0x39f9
cmpl $0x1, %esi
jne 0x3a30
movl $0x4, %edi
movl $0x8, %esi
callq 0x31b0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rax, (%rbx)
jmp 0x3a30
movl $0x4, %edi
movl $0x8, %esi
callq 0x31b0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rax, 0x10(%rbx)
jmp 0x3a30
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rax, (%rbx)
movl $0x4, %edi
movl $0x4, %esi
callq 0x31b0
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, 0x20(%rdi)
jne 0x3c37
movl 0x28(%rbx), %esi
movq %rbx, %rdi
callq 0x39bc
movl 0x20(%rbx), %esi
cmpl 0x24(%rbx), %esi
jne 0x3c49
addl %esi, %esi
movq %rbx, %rdi
callq 0x3b78
movl 0x28(%rbx), %eax
cmpl $0x2, %eax
je 0x3c83
cmpl $0x1, %eax
je 0x3c70
testl %eax, %eax
jne 0x3c9b
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 0x3c9b
movq (%rbx), %rax
movslq 0x24(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movq %r14, (%rax,%rcx,8)
jmp 0x3c9b
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_O1/ADAPTLab[P]MuDBSCAN/vectorc.cpp
// Function: vector_free(vectorc*)
void vector_free(vectorc* v)
{
    int i;
    v->total = 0;
    v->capacity = 0;
    switch(v->type)
    {
        case INTEGER:
            free(v->intItems);
            break;

        case DOUBLE:
            free(v->doubleItems);
            break;

        case GROUP:
            for(i=0;i<v->total;i++)
            {
                free(v->groupItems[i]);
            }
            free(v->groupItems);
            break;
            
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq $0x0, 0x20(%rdi)
movl 0x28(%rdi), %eax
testl %eax, %eax
je 0x3cec
cmpl $0x2, %eax
je 0x3ce6
cmpl $0x1, %eax
jne 0x3cfc
cmpl $0x0, 0x24(%rbx)
jle 0x3cf0
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x3310
incq %r14
movslq 0x24(%rbx), %rax
cmpq %rax, %r14
jl 0x3ccc
jmp 0x3cf0
addq $0x10, %rbx
jmp 0x3cf0
addq $0x8, %rbx
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3310
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/ADAPTLab[P]MuDBSCAN/Data.cpp
// Function: initDataHdr(int)
DataHdr initDataHdr(int size)
{   
    DataHdr dataHdrInfo = (DataHdr)calloc(1, sizeof(struct dataHdr));
    // assert(dataHdrInfo != NULL);

    dataHdrInfo->uiCnt = 0;
    dataHdrInfo->localCnt = 0;
    dataHdrInfo->dataClstElem=(Data)calloc(size, sizeof(struct data));
    // assert(dataHdrInfo->dataClstElem!=NULL);

    return dataHdrInfo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl $0x1, %edi
movl $0x10, %esi
callq 0x31b0
movq %rax, %r14
movq $0x0, (%rax)
movslq %ebx, %rdi
movl $0x40, %esi
callq 0x31b0
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ADAPTLab[P]MuDBSCAN/Data.cpp
// Function: insertDataLstElemRemote(dataHdr*, double*, int, int)
void insertDataLstElemRemote(DataHdr dataHdrInfo, DataPoint iData, int parentId, int remoteIndex)
{

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

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

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

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

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movslq (%rdi), %r8
movq %r8, %r9
shlq $0x6, %r9
movl %r8d, 0x1c(%rax,%r9)
movq %rsi, (%rax,%r9)
leal 0x1(%r8), %esi
movl %esi, (%rdi)
movl $0x1, 0x8(%rax,%r9)
movl $0xffffffff, 0x38(%rax,%r9) # imm = 0xFFFFFFFF
movl %edx, 0xc(%rax,%r9)
movl %ecx, 0x10(%rax,%r9)
movl %ecx, 0x14(%rax,%r9)
movl %edx, 0x18(%rax,%r9)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x28(%rax,%r9)
movl $0x0, 0x30(%rax,%r9)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x20(%rax,%r9)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq %rsi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %rax
cmpq %r14, %rax
je 0x3f3e
movq %rdi, %r12
xorl %r15d, %r15d
leaq 0x13522(%rip), %rax     # 0x17364
movslq (%rax), %r13
movl $0x8, %esi
movq %r13, %rdi
callq 0x31b0
leaq (%r15,%r15,2), %rcx
testq %r13, %r13
jle 0x3e73
movq (%r14,%rcx,8), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %r13
jne 0x3e61
movq -0x30(%rbp), %rdx
movq 0x8(%rdx), %rdx
movl (%rdx,%r15,4), %edx
movq -0x38(%rbp), %rsi
movq 0x8(%rsi), %rsi
movl (%rsi,%r15,4), %esi
movq 0x8(%r12), %rdi
movslq (%r12), %r8
movq %r8, %r9
shlq $0x6, %r9
movl %r8d, 0x1c(%rdi,%r9)
movq %rax, (%rdi,%r9)
leal 0x1(%r8), %eax
movl %eax, (%r12)
movl $0x1, 0x8(%rdi,%r9)
movl $0xffffffff, 0x38(%rdi,%r9) # imm = 0xFFFFFFFF
movl %edx, 0xc(%rdi,%r9)
movl %esi, 0x10(%rdi,%r9)
movl %esi, 0x14(%rdi,%r9)
movl %edx, 0x18(%rdi,%r9)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x28(%rdi,%r9)
movl $0x0, 0x30(%rdi,%r9)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x20(%rdi,%r9)
movq (%r14,%rcx,8), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%r14,%rcx,8)
movq $0x0, 0x10(%r14,%rcx,8)
testq %rdi, %rdi
je 0x3f13
callq 0x3270
incq %r15
movq (%rbx), %r14
movq 0x8(%rbx), %rax
movq %rax, %rcx
subq %r14, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq %r15, %rcx
ja 0x3e3b
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %r14, (%rdi)
movq %rax, 0x8(%rdi)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rdi)
movq %rcx, (%rbx)
movq %rdx, 0x8(%rbx)
movq %rsi, 0x10(%rbx)
callq 0x41f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ADAPTLab[P]MuDBSCAN/Data.cpp
// Function: insertDataLstElemLocal(dataHdr*, double*, int)
void insertDataLstElemLocal(DataHdr dataHdrInfo, DataPoint iData, int rank)
{
    Data dataClstElem = dataHdrInfo->dataClstElem + dataHdrInfo->uiCnt;
    dataClstElem->id = dataHdrInfo->uiCnt; //ID represents local id. ID with respect to the local node
    dataClstElem->iData = iData;
    
    dataHdrInfo->uiCnt++;
    dataHdrInfo->localCnt++;
    
    dataClstElem->haloPoint = FALSE;
    dataClstElem->remoteIndex = -1;
    dataClstElem->actualProcessId = rank;

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

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

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

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
movq %rcx, %r8
shlq $0x6, %r8
movl %ecx, 0x1c(%rax,%r8)
movq %rsi, (%rax,%r8)
leal 0x1(%rcx), %esi
movl %esi, (%rdi)
incl 0x4(%rdi)
xorl %esi, %esi
movl %esi, 0x8(%rax,%r8)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %edi, 0x10(%rax,%r8)
movl %edx, 0xc(%rax,%r8)
movl %edi, 0x38(%rax,%r8)
movl %ecx, 0x14(%rax,%r8)
movl %edx, 0x18(%rax,%r8)
movq $0x0, 0x28(%rax,%r8)
movl %esi, 0x30(%rax,%r8)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x20(%rax,%r8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x12fa4(%rip), %rdi     # 0x16fa8
leaq -0x2c(%rbp), %rsi
callq 0x33e0
movq (%rbx), %r12
movq %rbx, -0x38(%rbp)
movq 0x8(%rbx), %rax
cmpq %r12, %rax
je 0x4103
xorl %r13d, %r13d
xorl %ebx, %ebx
leaq 0x13337(%rip), %rax     # 0x17364
movslq (%rax), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x31b0
leaq (%rbx,%rbx,2), %rcx
testq %r15, %r15
jle 0x405e
movq (%r12,%rcx,8), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %r15
jne 0x404c
movl -0x2c(%rbp), %edx
movq 0x8(%r14), %rsi
movslq (%r14), %rdi
movq %rdi, %r8
shlq $0x6, %r8
movl %edi, 0x1c(%rsi,%r8)
movq %rax, (%rsi,%r8)
leal 0x1(%rdi), %eax
movl %eax, (%r14)
incl 0x4(%r14)
movl %r13d, 0x8(%rsi,%r8)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x10(%rsi,%r8)
movl %edx, 0xc(%rsi,%r8)
movl %eax, 0x38(%rsi,%r8)
movl %edi, 0x14(%rsi,%r8)
movl %edx, 0x18(%rsi,%r8)
movq %r13, 0x28(%rsi,%r8)
movl %r13d, 0x30(%rsi,%r8)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x20(%rsi,%r8)
movq (%r12,%rcx,8), %rdi
movq %r13, 0x10(%r12,%rcx,8)
xorps %xmm0, %xmm0
movups %xmm0, (%r12,%rcx,8)
testq %rdi, %rdi
je 0x40d4
callq 0x3270
incq %rbx
movq -0x38(%rbp), %rax
movq (%rax), %r12
movq 0x8(%rax), %rax
movq %rax, %rcx
subq %r12, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq %rbx, %rcx
ja 0x4026
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %r12, (%rdi)
movq %rax, 0x8(%rdi)
movq -0x38(%rbp), %r8
movq 0x10(%r8), %rax
movq %rax, 0x10(%rdi)
movq %rcx, (%r8)
movq %rdx, 0x8(%r8)
movq %rsi, 0x10(%r8)
callq 0x41f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdebb(%rip), %rdi      # 0x12020
xorl %eax, %eax
callq 0x3050
leaq 0x131f1(%rip), %r15     # 0x17364
cmpl $0x0, (%r15)
jle 0x41a1
xorl %r12d, %r12d
leaq 0xdea7(%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 0x4183
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41de
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 0x41c2
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/ADAPTLab[P]MuDBSCAN/GList.cpp
// Function: GinitHdrNd()
GHdrNd GinitHdrNd()
{   
	GHdrNd HdrNdLst = (GHdrNd)calloc(1, sizeof(struct GhdrNd));
	// assert(HdrNdLst!=NULL);    

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x31b0
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42e7
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsi)
movq %rsi, 0x8(%rdi)
incl (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x447f
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsi)
movq %rsi, 0x8(%rdi)
incl (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x44ed
cmpq $0x0, 0x8(%rdi)
je 0x44ed
cmpl $0x0, (%rdi)
je 0x44ed
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
cmpq %rsi, (%rax)
je 0x44f0
movq %rax, %rcx
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x4511
cmpq %rsi, (%rax)
jne 0x44be
testq %rdi, %rdi
je 0x4511
cmpl $0x0, (%rdi)
je 0x4511
movq 0x10(%rax), %rdx
movq %rdx, 0x10(%rcx)
movq $0x0, 0x10(%rax)
decl (%rdi)
jmp 0x4513
xorl %eax, %eax
retq
testq %rdi, %rdi
je 0x4511
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x4511
movq 0x10(%rax), %rdx
movq %rdx, 0x8(%rdi)
decl %ecx
movl %ecx, (%rdi)
movq $0x0, 0x10(%rax)
jmp 0x4513
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movb $0x1, %cl
testq %rdi, %rdi
je 0x4559
cmpq $0x0, 0x8(%rdi)
je 0x4559
cmpl $0x0, (%rdi)
sete %cl
xorl %eax, %eax
testq %rsi, %rsi
je 0x4587
testb %cl, %cl
jne 0x4587
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x4585
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq $0x0, 0x10(%rax)
decl (%rdi)
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ADAPTLab[P]MuDBSCAN/RList.cpp
// Function: RinitNbHdr()
RNbHdr RinitNbHdr()
{
    RNbHdr nbHdrInfo = (RNbHdr)calloc(1, sizeof(struct RnbHdr));
    if(nbHdrInfo == NULL)
        return NULL;

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

    return nbHdrInfo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %edi
movl $0x18, %esi
callq 0x31b0
testq %rax, %rax
je 0x45af
movl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
jmp 0x45b1
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd1df(%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 0xd1ea(%rip), %rsi      # 0x12066
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3400
movl (%r14), %edx
movq 0x50(%r14), %rcx
movq 0x38(%r14), %r8
leaq 0xd205(%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_O1/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 0x124ef(%rip), %rax     # 0x173b8
incl (%rax)
movl $0x1, %edi
movl $0x60, %esi
callq 0x31b0
movq %rax, %rbx
movl $0x0, 0x20(%rax)
leaq 0x12499(%rip), %rax     # 0x17384
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movl %ecx, (%rbx)
xorl %eax, %eax
movq %rax, 0x38(%rbx)
movl 0x1c(%r14), %ecx
movl %ecx, 0x30(%rbx)
fldz
fstpt 0x40(%rbx)
movq %rax, 0x50(%rbx)
movq (%r14), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x18(%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_O1/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 0x123bd(%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 0x1238e(%rip), %rax     # 0x17388
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movl %ecx, 0x28(%rbx)
movq $0x0, 0x20(%rbx)
testq %r14, %r14
jle 0x5039
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 0x501a
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_O1/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 0x6696
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_O1/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 0x525c
movq %rax, %rbx
testq %r15, %r15
jne 0x5227
leaq 0x1214d(%rip), %rax     # 0x17364
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x31b0
movq %rax, %r15
movq %r15, (%rbx)
testq %r15, %r15
je 0x5254
testq %r14, %r14
jne 0x524b
leaq 0x12129(%rip), %rax     # 0x17364
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x31b0
movq %rax, %r14
movq %r14, 0x8(%rbx)
testq %r14, %r14
jne 0x525e
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_O1/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 0x52ce
cmpl $0x1, %eax
jne 0x531f
leaq 0x120de(%rip), %rax     # 0x17364
movslq (%rax), %rax
testq %rax, %rax
jle 0x531f
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 (%rcx,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x52b0
jmp 0x531f
leaq 0x1208f(%rip), %rax     # 0x17364
movslq (%rax), %rax
testq %rax, %rax
jle 0x531f
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 0x52ff
popq %rbp
retq